信号量实现进程互斥、同步、前驱关系

信号量的值=这种资源的剩余数量（如果信号量的值小于0，说明此时有进程在等待这种资源）

P(s)——申请一个资源，如果资源不够就阻塞等待

V（S）——释放一个资源S,如果有进程在等待该资源，则唤醒一个进程。

1，信号量机制实现进程互斥

（1）分析并发进程的关键活动，划定临界区（如：对临界资源打印机的访问就应放在临界区）

（2）设置互斥信号量mutex，初值为1

（3）在进入区P（mutex)——申请资源

（4）在退出区V(mutex)——释放资源

注意：对不同的临界资源需要设置不同的互斥信号量，p ,v操作必须成对出现。缺少P（mutex)就不能保证临界资源的互斥访问，缺少V（mutex)会导致资源永不被释放，等待进程永不被唤醒。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/*记录型信号量的定义*/ typedef struct{ int value; struct process *L; }semaphore; /*信号量机制实现互斥*/ semaphore mutex=1; p1(){ ... p(mutex); 临界区代码... v(mutex); ... } p2(){ ... p(mutex); 临界区代码... v(mutex); ... }

　2,信号量实现进程同步

进程同步：要让个并发进程按要求有序地推进。

?

1 2 3 4 5 6 7 8 9 10

p1(){ 代码1； 代码2； 代码3； } p2(){ 代码4； 代码5； 代码6； }

　　比如，p1,p2并发执行，由于存在异步性，因此二者交替推进的次序是不确定的。

若p2的代码4要基于p1的代码1和代码2的运行结果才能执行，那么我们就必须保证代码4一定是在代码2 之后才会执行。这就是进程同步问题，让本来异步并发的进程互相配合，有序推进。

用信号量实现进程同步：

（1）分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行的两个操作（或两句代码）

（2）设置同步信号量S，初始为0

（3）在“前操作”之后执行V（S）

（4）在后操作之前执行P（s)

?

1 2 3 4 5 6 7 8

/*信号量机制实现同步*/ semaphore S=0;//初始化同步信号量，初始值为0 P1（）{                                                               P2（）{ 代码1；                                                                 P（s); 代码2；                                                                 代码4； V（s);//释放资源                                                         代码5； 代码3；                                                                 代码6； }                                                                           }

　　若先执行到V（s)操作，则S++后S=1.之后当执行到P（s)操作时，由于s=1,表示有可用资源，会执行S--，S的值变回0，P2进程不会执行block原语，而是继续往下执行代码4.

若先执行到P（s)操作，由于S=0，S--后S=-1，表示此时没有可用资源，因此P操作中会执行block原语，主动请求阻塞。之后当执行完代码2，继而执行V（S）操作，S++，使S变回0，由于此时有进程在该信号量对应的阻塞队列中，因此会在V操作中执行wakeup原语，唤醒P2进程。这样P2就可以继续执行代码4了。

3，信号量机制实现前驱关系

进程P1中有句代码S1，P2中有句代码S2，P3中有句代码S3......P6中有句代码S6。这些代码要求按如下前驱图所示的顺序来执行：

其实每一对前驱关系都是一个进程同步问题（需要保护一前一后的操作）

因此，

（1）要为每一对前驱关系各设置一个同步信号量；

（2）在“前操作”之后对相应的同步信号量执行V操作；

（3）在“后操作”之前对相应的同步信号量执行P操作；