进程之间的同步互斥与通信理发师问题操作系统课程设计
操作系统课程设计
目录
1. 课程设计目的 (3)
2. 设计要求 (3)
3. 问题具体描述 (3)
4. 设计分析 (3)
5. 设计分工 (4)
6. 数据结构说明 (4)
7. 系统结构说明 (4)
8. 系统调用说明 (4)
9. 分工设计说明 (5)
10. 算法流程图 (5)
11. 分工代码 (6)
12. 整体代码 (7)
13. 程序运行 (10)
14. 总结 (11)
1.课程设计目的
1.内容围绕操作系统原理中最重要的基本概念和基本原理展开
2.巩固对原理知识的学习效果
3.加深对基本概念的理解
4.学习如何将基本原理和实际设计、应用有机结合
5.锻炼本专业的基本能力
2.设计要求
1：进程间通信、并发(同步/互斥)、文件读写2：内存管理、Dll、Windows消息机制、IO （尚未最终定型）
3.问题具体描述
1.完成N个生产者和M个消费者之间的并发控制，N、M不低于5，数据发送和接收缓冲区大小不小于10个。
2.某个生产者进程生产的消息供K个消费者进程消费。K《=M。某些消费进程消费多个生产者生产的消息。生产者和消费者之间的对应关系可以在程序开始有一个文件中读入，也可以动态
调整。
3.每个生产进程生产M个消息后结束运行。如果一个消费者进程没有对应的生产者进程在运行后，也结束运行。
4.设计分析
课程设计的主要目的是了解并且掌握进程之间的同步互斥，和进程之间的通信问题。结合课本上的生产者与消费者问题可以从这方面来实现一个多进程的小系统，并且解决多个进程之间的通信，并发等问题，以此来达到课程设计的目的。理发师问题是将顾客看做生产者，将理发师作为消费者。设置一定数量的椅子的数目来作为缓存区的大小。顾客来到的时候坐在椅子上，将自己作为“产品”，理发师理发的时候从椅子上叫走顾客，相当于消费“产品”，从而达到了课程设计要求的前一个要求。
顾客作为生产者，每到来一个就使计数器count增加1，以便让理发师理发（相当于消费）至最后一个顾客（相当于产品）。并且，第1个到来的顾客应负责唤醒理发师；如果不是第1个到达的顾客，则在有空椅子的情况下坐下等待，
否则离开理发店（该消息可由计数器count获得）。主要有以下一些函数来实现整个问题的实现过程：
（1）用随机函数random()来产生进入理发店的顾客。
（2）定义理发师的理发函数cuthair()用来实现理发操作。
（3）定义顾客被理发的函数gethaircut()用来实现顾客被理发的操作。
（4）用顾客线程customer实现对顾客行为的控制。
（5）用理发师线程barber实现对理发师行为的控制。
（6）定义主函数main实现对两个线程的控制和执行操作。
5.设计分工
成员：李宁侯绍立
分工：
理发师进程、信号量的设置、理发师函数：xxx
顾客进程、顾客函数、主函数：xx
6.数据结构说明
本程序用到了数据结构中的队列，理发的顾客由随机函数产生，顾客遵从先到先理发的原则，但队列的长度限制为输入的理发店中的椅子的个数，当理发店的椅子没有空位的时候，到来的顾客主动退出加入队列。理发师对队列中的顾客进行先到先服务的原则理发。
7. 系统结构说明
（一）头文件声明
#include "windows.h"
#include "iostream.h"
#include "math.h"
（二）定义各种变量
int long waiting(0);
int chairs;
char open_door;
char close_door;
int count(0);
int finish(0);
（三）信号量的定义
HANDLE Mutex =::CreateMutex(NULL, FALSE, "Mutex");
HANDLE barbers =::CreateSemaphore(NULL, 1,1, "barbers");
HANDLE customers =::CreateSemaphore(NULL,0,3,"customers");
8. 系统调用说明
（1）CreateThread（）：创建线程
（2）CreateMutex（）：找出当前系统是否已经存在指定进程的实例。如果没有则创建一个互斥体，用来同步。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。CreateMutex（）函数可用来创建一个有名或无名的互斥量对象（3）CreateSemaphore()：CreateSemaphore() 是系统提供的API，包含在Windows.h 中，应用在同步的处理中。作用是创建一个新的信号机，执行成功，返回信号机对象的句柄；零表示出错。一旦不再需要，一定记住用CloseHandle关闭信号机的句柄。它的所有句柄都关闭以后，对象自己也会删除。一旦值大于零，信号机就会触发（发
出信号）。Semaphore是一个同步问题机制，不论是Event或Mutex，其他Process在执WaitForSingleObject时，就看当时的物件是Signal或UnSignal而决定是否等待，而Semaphore也相同，但是它要变成Signal
/UnSignal的状态，却有些不同，它是提供一个计数值，它允许在这个计数值之内，任何执行到WaitForSingleObject的Thread都不会停下来，而且每执行WaitForSingleObject一次，计数值就减一，当计数值变成0时，该Semaphore才会处於UnSignal的状态，而某个Thread ReleaseSemaphore时，便会将计数值增加，以便其他的Thread或本身可得Signal的讯号，而使WaitForSingleObject停止等待。
（4）ReleaseSemaphore（）：ReleaseSemaphore （）函数的作用是增加信号机的计数。如果成功，就调用信号机上的一个等待函数来减少它的计数。
（5）WaitForSingleObject（）：函数用来检测hHandle事件的信号状态，在某一线程中调用该函数时，线程暂时挂起，如果在挂起的dwMilliseconds毫秒内，线程所等待的对象变为
有信号状态，则该函数立即返回；如果超时时间已经到达dwMilliseconds毫秒，但hHandle所指向的对象还没有变成有信号状态，函数照样返回。参数dwMilliseconds有两个具有特殊意义的值：0和INFINITE。若为0，则该函数立即返回；若为INFINITE，则线程一直被挂起，直到hHandle所指向的对象变为有信号状态时为止。（6）ResumeThread（）:线程恢复函数，使用该函数能激活线程的运行，使CPU分配资源让线程恢复运行。
（7）ReleaseMutex（）：释放由线程拥有的一个互斥体
（8）Sleep（）：睡眠等待
9. 分工设计说明
需要用到的信号量：
HANDLE Mutex =::CreateMutex(NULL, FALSE, "Mutex");
实现顾客与理发师对公用缓存区的互斥操作HANDLE barbers
=::CreateSemaphore(NULL, 1,1, "barbers"); HANDLE customers
=::CreateSemaphore(NULL,0,3,"customers"); ::WaitForSingleObject(customers,INFINITE); 等待顾客进程的V(customer)操作
::WaitForSingleObject(Mutex,INFINITE); 申请操作顾客与理发师公用的缓存区
::ReleaseSemaphore(barbers,1,NULL); 释放信号量barbers
::ReleaseMutex(Mutex); 释放信号量Mutex，允许顾客操作缓存区
10.算法流程图
11.分工代码
#include "windows.h"
#include "iostream.h"
#include "math.h"
int long waiting(0); //等待理发的顾客人数
int chairs; //店中椅子的总
数目
char open_door; //开门
char close_door; //关门
int count(0); //顾客的序号int finish(0); //已经理完发的顾客人数
DWORD a;
HANDLE Mutex =::CreateMutex(NULL, FALSE, "Mutex"); //用来实现进程的互斥HANDLE barbers =::CreateSemaphore(NULL, 1,1, "barbers"); //定义信号量来进行线程间的同步
HANDLE customers =::CreateSemaphore(NULL,0,3,"customers"); //定义信号量来进行线程间的同步
int random()
//定义随机函数来产生顾客，并使两个顾客间的时间少于15秒
{
return (rand()*15000)/RAND_MAX;
}
void cuthair()
//理发师的理发函数，用时15秒
{
::Sleep (15000);
cout<<"理发结束!"< } DWORD WINAPI barber(LPVOID pParm1) //理发师线程 { while(true) { ::WaitForSingleObject(customers,INFINITE) ;//p(customers)，等待顾客 ::WaitForSingleObject(Mutex,INFINITE); //等待互斥量 waiting--; //等待的人数减1 ::ReleaseSemaphore(barbers,1,NULL); //释放信号量 ::ResumeThread(barbers); //唤醒顾客进程 ::ReleaseMutex(Mutex); //v(mutex); cuthair(); finish++; } return 0; } 12.整体代码 #include "windows.h" #include "iostream.h" #include "math.h" int long waiting(0); //等待理发的顾客人数 int chairs; //店中椅子的总数目 char open_door; //开门 char close_door; //关门 int count(0); //顾客的序号int finish(0); //已经理完发的 顾客人数 DWORD a; HANDLE Mutex =::CreateMutex(NULL, FALSE, "Mutex"); //用来实现进程的互斥HANDLE barbers =::CreateSemaphore(NULL, 1,1, "barbers"); //定义信号量来进行线程间的同步 HANDLE customers =::CreateSemaphore(NULL,0,3,"customers"); //定义信号量来进行线程间的同步 int random() //定义随机函数来产生顾客，并使两个顾客间的时间少于15秒 { return (rand()*15000)/RAND_MAX; } void cuthair() //理发师的理发函数，用时15秒 { ::Sleep (15000); cout<<"理发结束!"< } void gethaircut() // 顾客被理发的函数 { ::Sleep (15001); //顾客被理发的函数，为了和理发师之间有所区别，比理发师理发时间长1毫秒 cout<<"第"< } DWORD WINAPI customer(LPVOID pParm2) // 顾客线程 { ::WaitForSingleObject(Mutex ,INFINITE); //P(mutex)来进行互斥操作 count++; //来的是第几个顾客 cout<<"顾客敲门！第"< if (waiting //如果有空椅子 { if (waiting!=0) { cout<<"现在有"< } else cout<<"无人在等待理发"< waiting++; cout<<"剩余"< cout<<"有空位，顾客已坐下"< ::ReleaseSemaphore(customers,1,NULL); //V(customer) ::ResumeThread(customers); //唤醒理发师进程 ::ReleaseMutex(Mutex); //释放互斥量，以便其他线程使用 ::WaitForSingleObject(barbers,INFINITE);// 等待理发 gethaircut(); } else { cout<<"没有空椅子，第"< ::ReleaseMutex(Mutex); } return 0; } DWORD WINAPI barber(LPVOID pParm1) //理发师线程 { while(true) { ::WaitForSingleObject(customers,INFINITE) ;//p(customers)，等待顾客 ::WaitForSingleObject(Mutex,INFINITE); //等待互斥量 waiting--; //等待的人数减1 ::ReleaseSemaphore(barbers,1,NULL); //释放信号量 ::ResumeThread(barbers); //唤醒顾客进程 ::ReleaseMutex(Mutex); //v(mutex); cuthair(); finish++; } return 0; } int main(int argc, char* argv[]) //实现线程的操作 { cout<<"输入理发店中的椅子个数:"; cin>>chairs; cout<<"店中有"< cout<<"是否开始接待顾客?Y/N"< 学习中心： 专业： 年级：年春/秋季 学号： 学生： 题目：进程同步与互斥生产者-消费者问题 1.谈谈你对本课程学习过程中的心得体会与建议？ 转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程 1.1设计思路 在这次设计中定义的多个缓冲区不是环形循环的，并且不需要按序访问。其中生产者可以把产品放到某一个空缓冲区中，消费者只能消费被指定生产者生产的产品。本设计在测试用例文件中指定了所有生产和消费的需求，并规定当共享缓冲区的数据满足了所有有关它的消费需求后，此共享才可以作为空闲空间允许新的生产者使用。 本设计在为生产者分配缓冲区时各生产者之间必须互斥，此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一个产品进行消费时才需要互斥，它们在消费过程结束时需要判断该消费者对象是否已经消费完毕并释放缓冲区的空间。 1.2程序流程图 1.3基本内容 在设计程序时主要有三个主体部分、三个辅助函数和一个数据结构。 其中主体部分为一个主函数main（），用于初始化缓冲区和各个同步对象，并完成线程信息的读入，最后根据该组的线程记录启动模拟线程，并等待所有线程的运 Y 行结束后退出程序； 生产者函数Produce（）和消费者函数Consume（），生产者和消费者函数运行于线程中完成对缓冲区的读、写动作，根据此处生产消费的模型的特点，生产者和消费者之间通过使用同步对象实现了生产和消费的同步与互斥，是本实验的核心所在。 另外三个辅助性函数被生产者和消费者函数调用，是上述生产和消费函数中对缓冲区进行的一系列处理。 3)在实现本程序的消费生产模型时，具体的通过如下同步对象实现互斥： ①设一个互斥量h_mutex，以实现生产者在查询和保留缓冲区内的下一个位置时进行互斥。 ②每一个生产者用一个信号量与其消费者同步，通过设置h_Semaphore[MAX_THREAD_NUM]信号量 ③数组实现，该组信号量用于相应的产品已产生。同时用一个表示空缓冲区 实验二（2）进程同步 一、实验目的 1、生产者-消费者问题是很经典很具有代表性的进程同步问题，计算机中的很多同步问题都可抽象为生产者-消费者问题，通过本实验的练习，希望能加深学生对进程同步问题的认识与理解。 2、熟悉VC的使用，培养和提高学生的分析问题、解决问题的能力。 二、实验内容及其要求 1．实验内容 以生产者/消费者模型为依据，创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则；设计程序，实现生产者/消费者进程(线程)的同步与互斥； 三、实验算法分析 1、实验程序的结构图（流程图）； 2、数据结构及信号量定义的说明； (1) CreateThread ●功能——创建一个在调用进程的地址空间中执行的线程 ●格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, DWORD dwCreationFlags, Lpdword lpThread ); ●参数说明 lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。dwStackSize——定义原始堆栈大小。 lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。 lpParamiter——定义一个给进程传递参数的指针。 dwCreationFlags——定义控制线程创建的附加标志。 lpThread——保存线程标志符(32位) (2) CreateMutex ●功能——创建一个命名或匿名的互斥量对象 ●格式 HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName); bInitialOwner——指示当前线程是否马上拥有该互斥量(即马 ●参数说明 lpMutexAttributes——必须取值NULL。上加锁)。 lpName——互斥量名称。 (3) CreateSemaphore ●功能——创建一个命名或匿名的信号量对象 ●格式 HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCTSTR lpName ); ●参数说明 lpSemaphoreAttributes——必须取值NULL。 实验报告 1、实验名称 进程间的互斥和同步 2、小组成员：姓名+学号 3、实验目的 Linux命名信号量实现进程间的互斥和同步 4、实验背景知识 进程同步也是进程之间直接的制约关系，是为完成某种任务而建立的两个或多个线程，这个线程需要在某些位置上协调他们的工作次序而等待、传递信息所产生的制约关系。进程间的直接制约关系来源于他们之间的合作。比如说进程A需要从缓冲区读取进程B产生的信息，当缓冲区为空时，进程B因为读取不到信息而被阻塞。而当进程A产生信息放入缓冲区时，进程B才会被唤醒。 进程互斥是进程之间的间接制约关系。当一个进程进入临界区使用临界资源时，另一个进程必须等待。只有当使用临界资源的进程退出临界区后，这个进程才会解除阻塞状态。比如进程B需要访问打印机，但此时进程A占有了打印机，进程B会被阻塞，直到进程A释放了打印机资源,进程B才可以继续执行。 5、实验步骤演示 大概步骤： 先进行单次同步，把信号量先初始化为0，创建一个命名信号量，设置信号捕捉处理代码，安装捕捉信号；其次使用信号量进行同步和互斥的操作。 详细步骤： 1.创建一个命名信号量，sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V); 2.创建子进程，pid = fork(); 3.V操作，sem_post(sem); 4.P操作，sem_wait(sem); 5.等待子进程结束，wait(&status); 6.删掉在系统创建的信号量，sem_unlink(SEM_NAME); 7.彻底销毁打开的信号量，sem_close(sem); 8.信号捕捉处理，static void myhandler(void); 9.迭代同步,两个信号量，开始时一个为1，一个为0，一个进程执行完换另一个执行； 10.安装捕捉信号，signal(SIGINT,(void *)myhandler ); 11.创建一个命名信号量：sem1 = sem_open(SEM_NAME1, OPEN_FLAG, OPEN_MODE, 1);sem2 = sem_open(SEM_NAME2, OPEN_FLAG, OPEN_MODE, 0); 12.创建子进程，pid = fork(); 13.if(0 == pid) P操作：sem_wait(sem1); V操作：sem_post(sem2); 14.if(0 < pid) P操作：sem_wait(sem2); V操作：sem_post(sem1); 15.static void mysem(char *str) { int i = 0; //P操作 sem_wait(sem); while('\0' != str[i]) { printf("%c\n", str[i++]); sleep(1); } //V操作 sem_post(sem); } 进程排斥,在临界区设置PV操作 16.创建一个命名信号量，sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V); 17.if(0 == pid) { mysem("abcd"); } 18.if(0 < pid) { mysem("1234"); //等待子进程结束 wait(&status); //删掉在系统创建的信号量 sem_unlink(SEM_NAME); //彻底销毁打开的信号量 sem_close(sem); } 说明： 命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt 进程的同步互斥实验 实验目的 1、进一步认识并发执行的实质 2、分析进程竞争资源的现象，学习解决进程同步互斥的方法 实验内容 1、编写程序，使用相关函数实现父子进程对共享文件的同步互斥访问。 2、修改程序，观察对临界资源访问的互斥控制的作用。 实验基础 一、临界资源的互斥访问 为了实现多进程对临界资源的互斥访问，一个进程访问临界资源的典型程序段类似如下形式： { ………. 进入区 临界区; 退出区 其余代码; ………} 其中，进入区中判断资源是否可用，如果可用，则资源数量减1，进程进入临界区；否则进程阻塞等待。退出区中资源数量加1，唤醒阻塞等待该资源的进程。进入区和退出区都是原子操作。 操作系统中，通常用信号量来实现进入区和退出区，即P操作和V操作。为了实现用户程序中对某些资源的同步互斥访问，操作系统也提供了一些函数接口，功能类似于对特定临界区的进入区和退出区功能。 二、相关的系统调用 （1）lockf(files,function,size) ：用作锁定文件的某些段或者整个文件。 函数原型： #include 那么lockf的调用进程将被阻塞直到该区域解锁。 通过使用lockf函数，可实现多进程对共享文件进行互斥访问。进程的实现中，必须使得每个进程在使用文件前对文件加锁，使用文件后解锁。 （2）open：打开一个文件 函数原型：#include 实验四：进程的管道通信 实验题目 进程的管道通信 实验目的 加深对进程概念的理解，明确进程和程序的区别。学习进程创建的过程，进一步认识进程并发执行的实质。分析进程争用资源的现象，学习解决进程互斥的方法。学习解决进程同步的方法。掌握Linux系统中进程间通过管道通信的具体实现 实验内容 使用系统调用pipe()建立一条管道，系统调用fork()分别创建两个子进程，它们分别向管道写一句话，如： Child process1 is sending a message! Child process2 is sending a message! 父进程分别从管道读出来自两个子进程的信息，显示在屏幕上。 当然，仅仅通过屏幕上输出这两句话还不能说明实现了进程的管道通信，为了能够更好的证明和显示出进程的同步互斥和通信，在其中要加入必要的跟踪条件，如一定的输出语句等，来反映程序的并发执行情况 实验要求 这是一个设计型实验，要求自行、独立编制程序。两个子进程要并发执行。实现管道的互斥使用。当一个子进程正在对管道进行写操 作时，另一个欲写入管道的子进程必须等待。使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定。实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。 为了清楚的反应进程的同步，在子进程完成相应的操作后，调用sleep()函数睡眠一段时间（程序中定为3s）。父进程先执行wait()函数，当有子进程执行完毕后，会得到子进程的返回结果并清理子进程。若子进程没执行完，父进程一直执行wait()进行监听，知道有一个子进程执行完成为僵尸进程。 程序中用到的系统调用 因为程序时在linux系统上进行编写的，所以其中要利用到相关的linux提供的系统调用。 所用到的系统调用包含在如下头文件中。 #include 实验进程同步与互斥 一、实验目的 1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows 2000/XP中基本的同步对象，掌握相关API的使用方法。 3．了解Windows 2000/XP中多线程的并发执行机制，实现进程的同步与互斥。 二、实验内容及要求 1．实验内容 以生产者/消费者模型为依据，在Windows 2000环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 ●学习并理解生产者/消费者模型及其同步/互斥规则； ●学习了解Windows同步对象及其特性； ●熟悉实验环境，掌握相关API的使用方法； ●设计程序，实现生产者/消费者进程(线程)的同步与互斥； ●提交实验报告。 三、相关知识介绍 1．同步对象 同步对象是指Windows中用于实现同步与互斥的实体，包括信号量(Semaphore)、互斥量(Mutex)、临界区(Critical Section)和事件(Events)等。本实验中使用到信号量、互斥量和临界区三个同步对象。 同步对象的使用步骤： ●创建/初始化同步对象。 ●请求同步对象，进入临界区(互斥量上锁)。 ●释放同步对象(互斥量解锁)。 这些对象在一个线程中创建，在其他线程中都可以使用，实现同步与互斥。 2．相关API的功能及使用 我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含堆这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。 下面给出的是本实验使用到的API的功能和使用方法简单介绍。 (1) CreateThread ●功能——创建一个在调用进程的地址空间中执行的线程 ●格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, 进程同步与互斥 进程的PV操作 在操作系统中，P、V操作是进程管理中的难点。这是1968年荷兰人Dijkstra 给出的一种解决并发进程间互斥和同步关系的通用方法。 1. P、V操作的意义 定义了信号量及其上的P操作和V操作，来实现并发进程间的同步和互斥，甚至可以用来管理资源的分配。P、V操作因交换的信息量少，属于进程的低级通信。 2. 什么是信号量？ 信号量（semaphore）是由一个值和一个指针构成的数据结构。值为整型变 量，表示信息量的值；指针指向进程控制块（PCB）队列的队头，表示等待该信号量的下一个进程。如下图所示。 信号量的一般结构及PCB队列 信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的初值不能为负，且其值只能由P、V操作来改变。 3. P、V操作的含义 P、V操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量S进行操作，具体定义如下： P（S）： ①将信号量S的值减1，即S=S-1； ②如果S≥0，则该进程继续执行；否则该进程状态置为阻塞状态，进程PCB 排入信号量PCB队列末尾，放弃CPU，等待V操作的执行。 V（S）： ①将信号量S的值加1，即S=S+1； ②如果S≤0，释放信号量队列中第一个PCB所对应的进程，将进程状态由阻塞态改为就绪态。执行V操作的进程继续执行。 一般来说，信号量S≥0时，S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S的值加1；若S≤0，表示有某些进程正在等待该资源，因此要唤醒一个阻塞状态的进程，使之成为就绪状态。 4. 利用信号量和P、V操作实现进程互斥 一般地，n个进程利用信号量和P、V操作实现进程互斥的一般模型如下： 进程P 1进程P 2 ……进程Pn …… …… …… P（S）； P（S）； P（S）； 临界区；临界区；临界区； V（S）； V（S）； V（S）； …… …… …… …… 其中S是互斥信号量，初值为1。 使用P、V操作实现进程互斥时应该注意的问题是： （1）每个程序中，用户实现互斥的P、V操作必须成对出现，先做P操作，进临界区，后做V操作，出临界区。若有多个分支，要认真检查P、V操作的成对性。 （2）P、V操作应分别紧靠临界区的头尾部，临界区的代码应尽可能短，不能有死循环。 （3）互斥信号量的初值一般为1。 由于用于互斥的信号量sem与所有的并发进程有关，所以称之为公有信号量。公有信号量的值反映了公有资源的数量。只要把临界区置于P(sem)和V(sem) 习题解答: ?何谓与时间有关的错误? 举例说明之。 答：并发进程的执行实际上是进程活动的某种交叉，某些交叉次序可能得到错误结果。由于具体交叉的形成与进程的推进速度有关，而速度是时间的函数，因而将这种错误称为与时间有关的错误。 例如，两个并发进程的程序如下： int n=0; main( ){ 创建进程A； 创建进程B； }； A( ){ while(1){ n++; } }; B( ){ while(1){ 睡眠一段时间；printf(“%d”,n); n=0; } }; 假设进程A被部署在公园入口的终端上，用来记录一段时间内进入公园的人数，进程B被部署在公园的控制中心，用来输出一段时间内进入公园的总人数。进程A和进程B共享全局变量n，n表示记录下的人数。如果在进程B执行完打印语句后被进程A打断，进程A执行了若干次变量自增语句，之后进程B接着执行清0语句，那么进程A对n的累加丢失了，相当于进程B被打断的这段时间内进入公园的人没有被记录下来。发生与时间有关的错误。 ?有人说，假设两个进程之间没有共享内存，则二者之间没有公共变量，这种说法准确吗? 说明原因。 答：如果只从用户空间考虑，这种说法是正确的。但从操作系统的角度来说并不准确。两个没有公共内存的用户进程可能同时（宏观）进入操作系统，并访问操作系统空间中的公共变 量。 ?何谓忙式等待? 是否还有其它方式的等待? 比较它们之间的联系和差别。 答：不进入等待状态的等待称为忙式等待。另一种等待方式是阻塞式等待，进程得不到共享资源时将进入阻塞状态，让出CPU给其他进程使用。忙等待和阻塞式等待的相同之处在于进程都不具备继续向前推进的条件，不同之处在于处于忙等待的进程不主动放弃CPU，尽管CPU 可能被剥夺，因而是低效的；而处于阻塞状态的进程主动放弃CPU，因而是高效的。 ?下列进程互斥方法哪些存在忙式等待问题? （1）软件: 面包店算法(2) 硬件: TS指令(3) 关中断指令 答：（1）、（2）存在忙等待问题。 ?为何开关中断进程互斥方法仅在单CPU系统中是有效的？ 答：关中断方法不适用于多CPU系统，因为关中断只能保证CPU不由一个进程切换到另外一个进程，从而防止多个进程并发地进入公共临界区域。但即使关中断后，不同进程仍可以在不同CPU上并行执行关于同一组共享变量的临界区代码. ?在多处理机系统中，软件互斥方法是否有效？为什么？ 答：依然有效。多处理机并行与单处理并发之间的差别在于程序交叉的粒度，单处理机机环境中进程交叉发生在指令之间，多处理机环境中进程交叉发生在指令周期之间。由于纯软件互斥算法并不依赖特殊的硬件指令(如test_and_set)，指令之间的交叉与指令周期之间的交叉结果相同。 ?试分析临界区域的大小与系统并发性之间的关系。 答：关于同一组变量的临界区域是不能并发执行的代码，临界区越大，并发性越差，因而编写并发程序应尽量缩小临界区域范围。 ?设CR1是关于一组共享变量SV1的临界区域，CR2是关于另外一组共享变量SV2的临 同步和互斥的区别 信号量互斥量条件变量 同步和互斥 一、信号量：用于进程间通信（linux中用于线程） 独立于进程在两个进程中都要初始化，若一个已创建，则另一个获取可以执行多次v操作，然后再执行p操作 信号量的一些概念： 以下是信号灯（量)的一些概念: 信号灯与互斥锁和条件变量的主要不同在于”灯”的概念，灯亮则意味着资源可用，灯灭则意味着不可用。如果说后两中同步方式侧重于”等待”操作，即资源不可用的话，信号灯机制则侧重于点灯，即告知资源可用；没有等待线程的解锁或激发条件都是没有意义的，而没有等待灯亮的线程的点灯操作则有效，且能保持灯亮状态。当然，这样的操作原语也意味着更多的开销。 信号灯的应用除了灯亮/灯灭这种二元灯以外，也可以采用大于1的灯数，以表示资源数大于1，这时可以称之为多元灯。 二、互斥量：（用于在线程间的通信） 1、在一个进程中创建 三、信号量与互斥量的区别 1. 互斥量用于线程的互斥，信号量用于线程的同步。 这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。 互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源 以上区别是主要想记住的。 note:信号量可以用来实现互斥量的功能 2. 互斥量值只能为0/1，信号量值可以为非负整数。 也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。3、互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。 4、作用域 信号量: 进程间或线程间(linux仅线程间) 互斥锁: 线程间 5、上锁时 信号量: 只要信号量的value大于0，其他线程就可以sem_wait(p操作-1)成功，成功后信号量的value减一。若value值不大于0，则 1、测量控制系统中的数据采集任务把所采集的数据送一单缓冲区；计算任务则从该缓冲区中取出数据并进行计算。试写出利用信号量机制实现两者共享单缓冲区的同步算法。 Var Sempty，Sfull: semaphore:= 1,0 Begin Parbegin Collection:begin repeat 采集一个数据； wait(Sempty); 数据放入缓冲区； signal(Sfull); untill false; end; Compute:begin repeat wait(Sfull); 从缓冲区取出数据; signal(Sempty); 计算; ` until false; end; Parend End 2、有一阅览室，共有100个座位。读者进入时必须先在一种登记表上登记，该表为每一座位列一个表目，包括座号和读者姓名。读者离开时要注销掉登记内容。试用wait和signal原语描述读者进程的同步问题。 var mutex, readcount :semaphore := 1,100; Begin Parbegin Process Reader:begin repeat wait(readcount); wait(mutex); <填入座号和姓名完成登记>； signal(mutex); <阅读> wait(mutex) <删除登记表中的相关表项，完成注销> signal(mutex); signal(readcount); until false; end; parend; End; 1）、桌上有一空盘，只允许放一个水果，爸爸专向盘中放苹果，妈妈专向盘中放桔子；女儿专吃盘中的苹果，儿子专吃盘中的桔子；试用wait 和signal原语实现爸爸、妈妈、女儿、儿子之间的同步问题。 var Sempty, Sapple, Sorange,: semaphore:= 1,0,0; begin parbegin Father: begin repeat wait(Sempty); 进程间互斥与同步 实验内容： 编写算法，实现进程间对临界资源的互斥访问以及进程间的同步关系。 实验要求： 1、要求进程互斥使用文本文件； 2、假定文本文件txt1最大可写入30个字符； 3、写满后复制进程将文本文件的内容复制到另一个文本文件txt2中（无长度限制）。 4、复制进程复制完毕写入进程可再重新写入，重复执行3，4，直到给出停止命令。 5、实现进程间的同步和互斥。 代码： #include sem_b.sem_num=0; sem_b.sem_op=1; sem_b.sem_flg=SEM_UNDO; if(semop(sem_id,&sem_b,1)==-1) { cout<<"error"< 实验一进程同步与互斥 一、实验目的 1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows 2000/XP中基本的同步对象，掌握相关API的使用方法。 3．了解Windows 2000/XP中多线程的并发执行机制，实现进程的同步与互斥。 二、实验内容及要求 1．实验内容 以生产者/消费者模型为依据，在Windows 2000环境下创建一个控制台进程，在该进程 中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 , 学习并理解生产者/消费者模型及其同步/互斥规则； , 学习了解Windows同步对象及其特性； , 熟悉实验环境，掌握相关API的使用方法； , 设计程序，实现生产者/消费者进程(线程)的同步与互斥； , 提交实验报告。 三、相关知识介绍 1．同步对象 同步对象是指Windows中用于实现同步与互斥的实体，包括信号量(Semaphore)、互斥量(Mutex)、临界区(Critical Section)和事件(Events)等。本实验中使用到信号量、互斥量和临 界区三个同步对象。 同步对象的使用步骤： , 创建/初始化同步对象。 , 请求同步对象，进入临界区(互斥量上锁)。 , 释放同步对象(互斥量解锁)。 这些对象在一个线程中创建，在其他线程中都可以使用，实现同步与互斥。 2．相关API的功能及使用 我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含堆这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。 下面给出的是本实验使用到的API的功能和使用方法简单介绍。 (1) CreateThread , 功能——创建一个在调用进程的地址空间中执行的线程 , 格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, DWORD dwCreationFlags, Lpdword lpThread ); , 参数说明 lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。 1、有一个仓库可存放A、B两种零件，最大库容量各为m个。生产车间不断地取A和B 进行装配，每次各取一个。为避免零件锈蚀，按先入库者先出库的原则。有两组供应商分别不断地供应A和B，每次一个。为保证配套和合理库存，当某种零件比另一种零件超过n(n 实验二 进程（线程）的同步与互斥 一、实验目的 1． 掌握基本的同步与互斥算法，理解生产者消费者模型。 2． 学习使用Windows 中基本的同步对象，掌握相关API 的使用方法。 3． 了解Windows 中多线程的并发执行机制，实现进程的同步与互斥。 二、实验内容 1． 实验内容 以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n 个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2． 实验要求 ● 学习并理解生产者/消费者模型及其同步/互斥规则； ● 学习了解Windows 同步对象及其特性； ● 熟悉实验环境，掌握相关API 的使用方法； ● 设计程序，实现生产者/消费者进程(线程)的同步与互斥； 三、相关API 的功能及使用 我们利用Windows SDK 提供的API 编程实现实验题目要求，而VC 中包含有Windows SDK 的所有工具和定义。要使用这些API ，需要包含堆这些函数进行说明的SDK 头文件——最常见的是Windows.h(特殊的API 调用还需要包含其他头文件)。 下面给出的是本实验使用到的API 的功能和使用方法简单介绍。 (1) CreateThread ● 功能——创建一个在调用进程的地址空间中执行的线程 ● 格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, Buffer(共享内存) 生产者 消费者 信号量互斥量条件变量 同步和互斥 一、信号量：用于进程间通信（linux中用于线程） 独立于进程在两个进程中都要初始化，若一个已创建，则另一个获取可以执行多次v操作，然后再执行p操作 信号量的一些概念： 以下是信号灯（量)的一些概念: 信号灯与互斥锁和条件变量的主要不同在于”灯”的概念，灯亮则意味着资源可用，灯灭则意味着不可用。如果说后两中同步方式侧重于”等待”操作，即资源不可用的话，信号灯机制则侧重于点灯，即告知资源可用；没有等待线程的解锁或激发条件都是没有意义的，而没有等待灯亮的线程的点灯操作则有效，且能保持灯亮状态。当然，这样的操作原语也意味着更多的开销。 信号灯的应用除了灯亮/灯灭这种二元灯以外，也可以采用大于1的灯数，以表示资源数大于1，这时可以称之为多元灯。 二、互斥量：（用于在线程间的通信） 1、在一个进程中创建 三、信号量与互斥量的区别 1. 互斥量用于线程的互斥，信号量用于线程的同步。 这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。 互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源 以上区别是主要想记住的。 note:信号量可以用来实现互斥量的功能 2. 互斥量值只能为0/1，信号量值可以为非负整数。 也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。3、互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。 4、作用域 信号量: 进程间或线程间(linux仅线程间) 互斥锁: 线程间 5、上锁时 信号量: 只要信号量的value大于0，其他线程就可以sem_wait(p操作-1)成功，成功后信号量的value减一。若value值不大于0，则sem_wait 操作系统进程同步实验报告 实验三：进程同步实验 一、实验任务： （1）掌握操作系统的进程同步原理； （2）熟悉linux的进程同步原语； （3）设计程序，实现经典进程同步问题。 二、实验原理： （1）P、V操作 PV操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下： P（S）：①将信号量S的值减1，即S=S-1； ②如果S30，则该进程继续执行；否则该进程置为等待状态，排入等待队列。 V（S）：①将信号量S的值加1，即S=S+1； ②如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。（2）信号量 信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的值仅能由PV操作 来改变。 一般来说，信号量S30时，S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S的值加1；若S￡0，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。 （3）linux的进程同步原语 ①wait()；阻塞父进程，子进程执行； ②#include 进程同步机制与互斥-生产者消费者问题
实验二(1)进程同步
进程间的同步和互斥-
进程同步互斥1
操作系统实验-进程同步与互斥
Windows下进程同步与互斥
进程同步与互斥汇总
同步与互斥
同步和互斥的区别_
[操作系统]经典进程同步问题题库
计算机操作系统_进程间互斥与同步
实验一 进程同步与互斥
进程同步经典问题
实验二 进程(线程)的同步与互斥
同步和互斥的区别
操作系统进程同步
相关主题
文本预览