目录
一.进程的同步与互斥
1.进程的异步和同步
2.进程互斥
3.进程互斥的软件实现方法
（1）单标志法
（2）双标志法
（3）双标志后检查
（4）Peterson算法
4.进程互斥的硬件实现方法
（1）中断屏蔽方法
（2）TestAndSet(TS指令/TSL指令)
（3）Swap指令（XCHG指令）
补充：
互斥锁
排号自旋锁
条件变量
二.信号量机制
1.信号量的类别
（1）整型信号量
（2）记录型信号量
2.信号量机制实现进程互斥
3.信号量机制实现进程同步
4.信号量机制实现前驱关系
一.进程的同步与互斥
1.进程的异步和同步
异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进。
例如：进程通信----管道通信
读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执行的先后顺序是不确定的。而实际应用中，又必须按照“写数据→读数据”的顺序来执行的。如何解决这种异步问题，就是“进程同步”所讨论的内容。
同步亦称直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作。
2.进程互斥
进程的“并发”需要“共享”的支持。各个并发执行的进程不可避免的需要共享一些系统资源(比如内存，又比如打印机、摄像头这样的I/O设备)
资源有两种共享方式：
(1)同时共享方式：系统中的某些资源，允许一个时间段内由多个进程“同时”对它们进行访问。
(2)互斥共享方式：系统中的某些资源，虽然可以提供给多个进程使用，但一个时间段内只允许一个进程访问该资源。
我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备(比如摄像头、打印机)都属于临界资源。此外还有许多变量、数据、内存缓冲区等都属于临界资源。对临界资源的访问，必须互斥地进行。
互斥，亦称间接制约关系。进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源。
对临界资源的互斥访问，从逻辑上分为如下四个部分：
进入区：
负责检查是否可进入临界区，若可进入，则应设置正在访问临界资源的标志(可理解为“上锁”)，以阻止其他进程同时进入临界区
临界区：
访问临界资源的那段代码
退出区：
负责解除正在访问临界资源的标志(可理解为“解锁”)
剩余区：
做其他处理
注意进入区和临界区的区别：
临界区是进程中访问临界资源的代码段。
进入区和退出区是负责实现互斥的代码段。
为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则:
1.空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区;
2.忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待；
3.有限等待。对请求访问的进程，应保证能在有限时间内进入临界区(保证不会饥饿);
4.让权等待。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待。
注：这里的忙等待可以类比while(1){}循环，占着CPU但不运行进程。
3.进程互斥的软件实现方法
（1）单标志法
两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予
例如：
turn表示当前允许进入临界区的进程号,在进入区时，进程会判断自己的进程号是否与允许进入临界区的进程号相同,若此时turn不等于自己的编号时，说明此时临界区只允许另一个进程进入。以上述例子为例：
turn 的初值为0，即刚开始只允许0号进程进入临界区。
若 P1先上处理机运行，则会一直卡在 ⑤。直到 P1 的时间片用完，发生调度，切换 P0 上处理机运行。
代码 ① 不会卡住 PO，PO可以正常访问临界区，在 P0访问临界区期间即时切换回 P1，P1依然会卡在 ⑤。直到P1进程的时间片用完，操作系统会再次调度P0进程，让其上处理机运行。只有到P0进程运行到退出区时，P1进程才能跳过while，使用临界区资源。因此，该算法可以实现“同一时刻最多只允许一个进程访问临界区
这个算法只能按 P0 →P1→P0 →P1→…这样轮流访问。这种必须“轮流访问”带来的问题是，如果此时允许进入临界区的进程是 P0，而P0一直不访问临界区，那么虽然此时临界区空闲，但是并不允许P1访问。因此，单标志法存在的主要问题是:违背“空闲让进”原则。
（2）双标志法
设置一个布尔型数组flag[]，数组中各个元素用来标记各进程想进入临界区的意愿，比如
“flag[0]=ture”意味着0号进程P0现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把自身对应的标志flag[i]设为true，之后开始访问临界区。
以上图为例：
当flag[0]=false时,表示0号进程现在不想进入临界区，flag[0]=true时，表示0号进程现在想进入临界区。
1.每个进程在进入临界区之前，会先检查对方是否想进入临界区
2.若对方想进入临界区，此进程就会一直卡在while循环，若对方不想进入临界区，此进程就会把flag[i]设为true。
现在假设一种情况：
1.P0进程检查P1进程，发现P1进程并不想进入临界区，P1就会跳过while循环，P1接下来要执行②，在执行②之前，也就是flag[0]还没有切换为true，就切换到P0进程。
2.P1进程的⑤检测flag[0]=false，所以P1进程的while循环会被跳过，进入⑥，并且访问临界区。
3.若此时又切换为P0进程，flag[0]设为true，P0进程也会进入临界区。
若按照 ①⑤②⑥③⑦..的顺序执行，P0 和 P1将会同时访问临界区。因此，双标志先检查法的主要问题是:违反“忙则等待”原则。
根本原因在于，进入区的“检查”和“上锁”两个处理不是一气呵成的。“检查”后，“上锁”前可能发生进程切换。
（3）双标志后检查
双标志先检查法的政版。前一个算法的问题是先“检查”后“上锁”，但是这两个操作又无法一气呵成，因此导致了两个进程同时进入临界区的问题。因此，人们又想到先“上锁”后“检查的方法，来避免上述问题。
先检查法和后检查法都是用flag标志表示是否进入临界区的意愿，区别在于：
先检查法是先“检查”后“上锁”
后检查法是先“上锁”后“检查”
若P0进程想要进入临界区，那么P0先将flag[0]设为true，再检查P1是否想使用，若P1不想使用，P0就可以进入临界区访问临界资源。当P0访问完毕，再flag[0]=false，退出临界区。
接下来考虑并发的情况：
若P0表示自己想访问临界资源，即flag[0]=true，此时进程切换到P1，P1也想访问临界资源，即flag[1]=true，此时P0发现P1也想进入临界区，就会卡在while循环，同理，P1发现P0想访问临界区，也会卡在while循环。所以P0和P1都无法进入临界区。
若按照 ①⑤②⑥...的顺序执行，P0 和 P1将都无法进入临界区
因此，双标志后检查法虽然解决了“忙则等待”的问题，但是又违背了“空闲让进”和"有限等待"（每个进程都进入不了临界区，就会造成无限等待的情况）原则，会因各进程都长期无法访问临界资源而产生“饥饿”现象。
两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区。
（4）Peterson算法
Peterson方法结合了双标志法与单标志法，例如：
flag用于表示是否有进入临界区的意愿，turn用来表示优先让哪个进程进入临界区。
以P0进程为例，若P0想要访问临界区，会把flag设为true，同时把turn的值设为对方的编号，也就表示可以优先让对方使用临界资源。
while(flag[1] && turn==1)用来检查P1是否想用，若对方想用，那么P0就会停留在while中，若P1不想使用，那么P0就会进入临界区，使用完后，就会将flag[0]=false
若按照①⑥②⑦⑧…的顺序执行，①表示P0想进入临界区，⑥表示P1想进入临界区，②表示可以优先让P1访问临界区，⑦表示P1可以优先让P0访问临界区，接下来P1要运行⑧，但是P1发现
flag[0]=1并且turn==0，所以P1会卡在while循环中，直到进程切换为P0，并且P1没有进入临界区的意愿，那么P0可以顺利进入临界区。
所以Peterson 算法用软件方法解决了进程互斥问题，遵循了空闲让进、忙则等待、有限等待 三个原则，但是依然未遵循让权等待的原则。
让权等待即若进程进入不了临界区，那么应该立即释放处理机，但是这个算法的规则是，若某进程进入不了临界区，那么会一直停留在while()循环中，一直占用着CPU，检查while循环是否得到满足，有两种情况：
1.在时间片内，另一个进程flag[i]=0，即不想访问临界区
2.这个进程不想访问临界区，那么另外一个进程就可以跳过while循环，顺利执行
4.进程互斥的硬件实现方法
我们可以看到，上述软件实现的方法都未遵循让权等待的原则，所以接下来介绍硬件实现方法。
（1）中断屏蔽方法
利用“开/关中断指令”实现(与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况)
关中断即不允许当前进程被中断，也必然不会发生进程切换，直到当前进程访问完临界区，再执行开中断指令，才有可能有别的进程上处理机并访问临界区。
优点：简单，高效
缺点：不适用于多处理机（也就是另外一个用户进程也要使用临界资源，也使用这样的方法，那么就会导致两个进程同时访问临界资源的情况)；只适用于操作系统内核进程，不适用于用户进程(因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险)
（2）TestAndSet(TS指令/TSL指令)
简称 TS 指令，也有地方称为TestAndSetLock指令，或 TSL指令
TSL指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是用C语言描述的逻辑
若当前临界区已经被加锁，那么在while循环中会一直为true，一直到lock被当前进程在退出区改为false，那么跳出while循环，并且该进程访问临界资源，直到此进程在退出区lock=false，临界资源被解锁，即：
相比软件实现方法，TSL指令把“上锁”和“检查”操作用硬件的方式变成了一气呵成的原子操作。
优点:实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境 。
缺点:不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。
（3）Swap指令（XCHG指令）
有的地方也叫 Exchange 指令，或简称 XCHG 指令。
swap 指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是用C语言描述的逻辑:
逻辑上来看 Swap和 TSL并无太大区别，都是先记录下此时临界区是否已经被上锁(记录在 old 变量上)，再将上锁标记lock 设置为true，最后检查 old，如果old为false, 则说明之前没有别的进程对临界区上锁，则可跳出循环，进入临界区。
以下while循环对应两种情况：
① lock=false，swap执行一次，把lock=true，即上锁，old=false，即可以往下执行
② lock=true，一直停留在while循环中，即一直执行swap，直到lock=false后执行①
优点:实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞;适用于多处理机环境。
缺点:不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。
补充：
互斥锁
解决临界区最简单的工具就是互斥锁(mutex lock)。一个进程在进入临界区时应获得锁;在退出临界区时释放锁。函数acquire()获得锁，而函数release()释放锁。
每个互斥锁有一个布尔变量 available，表示锁是否可用。如果锁是可用的，调用 acqiure()会成功，且锁不再可用。当一个进程试图获取不可用的锁时，会被阻塞，直到锁被释放。
acquire()或release()的执行必须是原子操作，因此互斥锁通常采用硬件机制来实现。
互斥锁的主要缺点是忙等待，当有一个进程在临界区中，任何其他进程在进入临界区时必须连续循环调用 acquire()。当多个进程共享同一CPU时，就浪费了CPU周期。因此，互斥锁通常用于多处理器系统，一个线程可以在一个处理器上等待，不影响其他线程的执行。
需要连续循环忙等的互斥锁，都可称为自旋锁(spinlock)，如TSL指令、swap指令、单标志法。
特性:
1.需忙等，进程时间片用完才下处理机，违反“让权等待”
2.优点:等待期间不用切换进程上下文，多处理器系统中，若上锁的时间短，则等待代价很低
3.常用于多处理器系统，一个核忙等，其他核照常工作，并快速释放临界区
4.不太适用于单处理机系统，忙等的过程中不可能解锁，只有该进程时间片用完，另一个进程上处理机（上锁），并且使用完临界资源，退出临界区，该进程才能再次获得锁。
排号自旋锁
自旋锁中有一种排号自旋锁：
排号锁就是要给用锁的线程进行排号，然后锁沿着这个号进行传递，因此可以说锁的竞争就变成了一个先进先出的等待队列。
struct lock
{volatile int owner;volatile int next;
};void lock_init(struct lock *lock)
{//初始化排号锁lock->owner = 0;lock->next = 0;
}void lock(struct lock*lock)
{//拿取自己的序号volatile int my_ticket = atomic_FAA(&lock->next,1);while(lock->owner != my_ticket); //循环忙等
}void unlock(struct lock*lock)
{//传递给下一位竞争者lock->owner++;
}
owner表示当前的锁持有序号，next表示下一个需要分发的序号
第17行是拿取自己的序号，并累加，这样就不会拿取相同的序号
第18行是看当前锁的持有者是不是自己，不是就循环等待
第25行是释放锁，然后锁持有者向后传递。
条件变量
在生产者和消费者模型中，无剩余空位时，生产者会陷入循环等待，他可以不用循环等待的，这会浪费cpu资源，因此需要一种挂起/唤醒机制，条件变量就是为这个机制而设计的。
通过条件变量的接口，一个线程可以停止使用CPU并将自己挂起，当等待的条件满足时，其他线程会唤醒该挂起的线程让其继续执行。
int empty_slot = 5;
int filled_slot = 0;
struct cond empty_cond;
struct lock empty_cnt_lock;
struct cond filled_cond;
struct lock filled_cnt_lock;void producer(void)
{int new_msg;while(TRUE){new_msg = produce_new();lock(&empty_cnt_lock);while(empty_slot == 0){cond_wait(&empty_cond, &empty_cnt_lock);}empty_slot --;unlock(&empty_cnt_lock);buffer_add_safe(new_msg);lock(&filled_cnt_lock);filled_slot ++;cond_signal(&filled_cond);unlock(&filled_cnt_lock);}
}
empty_cnt_lock和filled_cnt_lock是来保护对共享计数器empty_slot与filled_slot的修改的锁，这个锁设计的目的是在使用条件变量时，必须要搭配互斥锁一起使用。
这里设置了两个条件，empty_cond 缓冲区无空位和filled_cond 缓冲区无数据。
当生产者要写数据时发现没有空位，则通过cond_wait函数挂起，条件是empty_cond无空位，搭配的互斥锁是empty_cnt_lock，后边那个cond_signal是唤醒线程，由于写入数据则缓冲区存在数据了，可以唤醒由于缓冲区无数据而挂起的消费者线程。
struct cond{struct thread *wait_list;
};void cond_wait(struct cond *cond, struct lock *mutex)
{list_append(cond->wait_list, thread_self());//将线程加入等待队列atomic_block_unlock(mutex); //原子挂起并放锁//这里为一个原子操作，它将当前线程从条件变量的等待队列中移除，并在同一原子操作中释放了互斥锁 mutexlock(mutex); //重新获得互斥锁（被唤醒后）
}void cond_signal(struct cond *cond)
{if(!list_empty(cond->wait_list))//看是否有线程等待在条件变量上wakeup(list_remove(cond->wait_list)); //操作系统提供的唤醒
}void cond_broadcast(struct cond *cond) //广播操作，用于唤醒所有等待在条件变量上的线程
{while(!list_empty(cond->wait_list))wakeup(list_remove(cond->wait_list));
}
参考原文链接：https://blog.csdn.net/weixin_38849460/article/details/112334023
二.信号量机制
由于上述的进程互斥实现方法存在以下问题：
1.在双标志先检查法中，进入区的“检查”，“上锁”操作无法一气呵成，从而导致了两个进程有可能同时进入临界区的问题;
2.所有的解决方案都无法实现“让权等待”。
为解决上述问题，提出了信号量机制
用户进程可以通过使用操作系统提供的一对原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。
原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。原语是由关中断/开中断指令实现的。软件解决方案的主要问题是由“进入区的各种操作无法一气呵成”，因此如果能把进入区、退出区的操作都用“原语”实现，使这些操作能“一气呵成”就能避免问题。
一对原语:wait(S)原语和 signal(S)原语，可以把原语理解为我们自己写的函数，函数名分别为 wait和 signal，括号里的信号量S其实就是函数调用时传入的一个参数。wait、signal 原语常简称为P、V操作。因此，做题的时候常把wait(S)、signal(s)两个操作分别写为 P(S)、V(S)
信号量其实就是一个变量(可以是一个整数，也可以是更复杂的记录型变量)，可以用一个信号量来表示系统中某种资源的数量，比如:系统中只有一台打印机，就可以设置一个初值为1的信号量。
1.信号量的类别
（1）整型信号量
用一个整数型的变量作为信号量，用来表示系统中某种资源的数量。
与普通整数变量的区别：对信号的操作只有三种：初始化，P操作，V操作。
例如：某计算机系统中有一台打印机
while(S<=0);
S=S-1;
这两个句子与双标志先检查法的原理是相同的，先检查资源是否足够，如果资源够占用一个资源，但是这里是用原语实现，所以就避免了双标志先检查法中两个进程同时进入临界区的问题。
同时这里的while循环也会导致不满足“让权等待”原则，会发生"忙等"
实质上，这里也不是忙等，忙等的情况下，若该进程时间片完，会发生时间片中断，切换到其他进程，但这里是原子操作，进程是不可被中断的。
这里的代码只是演示，不是简单的while循环，而是先给信号量上一个自旋锁，判断如果资源不够，那么会先释放自旋锁，紧跟goto语句回到获取自旋锁的那一步，那么下次回到这个进程时会再次对信号量上自旋锁。
这里也是看了很多资料总结了一下，若佬们有其他见解，请在评论区指教指教，谢谢佬们
（2）记录型信号量
整型信号量的缺陷是存在“忙等”问题，因此人们又提出了“记录型信号量”，即用记录型数据结构表
示的信号量。
如果剩余资源数不够使用block语使进程从运行态进入阻塞态，并把挂到信号量S的等待队列(即阻塞队列)中
若S.value<=0,表示释放资源后，若还有别的进程在等待这种资源，则使用wakeup原语唤醒等待队列中的一个进程，该进程从阻塞态变为就绪态。
例如：某计算机系统中有2台打印机，则可在初始化信号量S时将S.value的值设为2，队列S.L设置为空
1.当分配给P0进程CPU时，剩余资源数会减1
2.接下来CPU分配给P1进程，剩余的一个资源分配给P1进程
3.接下来CPU分配给P2进程，剩余资源减1，当前剩余资源为-1，value的值在减1之后小于0，说明此时系统当中没有多余资源分配给进程了。因此这个进程会在wait()原语中，主动执行block原语，即把自己阻塞的原语，因此P2进程会被放到打印资源的等待队列中。
S.value=0,资源恰好分配完S.value=-1,有1个进程在等待
4.同理，CPU为P3进程服务，没有多余的资源，所以P3也会被放入等待队列的队尾中
S.value=-2,有2个进程在等待
5.P0在使用完打印机后会进行signal操作，首先会让value值做加1的操作，即剩余资源数加1，此时S.value的值会从-2变为-1，若S.value依然是小于等于0（注意这里的0，因为是减完后才等于0，所以等于0，也有进程在等待队列中）的，说明等待队列中依然有进程等待，signal（S）操作中，会主动执行wakeup原语用于唤醒等待队列中队头的进程，即P2，并且将P0释放的打印机资源分配给P2，P2从等待队列中移除，若此时P2进程得到CPU，P2就能使用打印机资源了。
6.P2使用完打印机后也会进行signal操作，首先将value减1，接着使用wqakeup原语唤醒等待队列中对头的进程P3，并且将打印机资源分配给P3，P3会从等待队列中移除，此时等待队列为空。若此时P3被分配CPU，就可以使用打印机资源。
7.若此时P1使用完进程释放资源，剩余资源加1，即从0变为1，此时剩余资源数已经大于0了，说明没有进程在等待队列中，所以执行signal操作时，并不需要执行wakeup原语，唤醒进程。
8.最后P3使用完打印机资源后，会对打印机资源释放，系统回收打印机资源，剩余资源数从1变为2,也不需要执行wakeup原语。
总结：
wait(S)、signal(s)也可以记为 P(S)、V(S)，这对原语可用于实现系统资源的“申请”和“释放”
对信号量S的一次P操作意味着进程请求一个单位的该类资源，因此需要执行 S.value--，表示资源数减1，当S.value<0时表示该类资源已分配完毕，因此进程应调用 block 原语进行自我阻塞(当前运行的进程从运行态--->阻塞态)，主动放弃处理机，并插入该类资源的等待队列S.L中。可见，该机制遵循了“让权等待”原则，不会出现“忙等”现象。
对信号量S的一次V操作意味着进程释放一个单位的该类资源，因此需要执行S.value++，表示资源数加1，若加1后仍是S.value<=0，表示依然有进程在等待该类资源，因此应调用 wakeup 原语唤醒等待队列中的第1个进程(被唤醒进程从阻塞态--->就绪态)
2.信号量机制实现进程互斥
实现进程互斥操作的步骤如下：
1.分析并发进程的关键活动，划定临界区(如:对临界资源打印机的访问就应放在临界区)
2.设置互斥信号量 mutex，初值为 1
3.在进入区 P(mutex)--申请资源
4.在退出区 V(mutex)--释放资源
此时P1进程申请进入临界区，由于此时互斥信号量为1，即临界资源为1，所以此时P1可以进入临界区，若P2也想进入临界区，就会被阻塞在P操作，等到P1进行V操作，释放资源后，P2进程才能被唤醒。
注：
1.队不同临界资源需要设置不同的互斥信号量，例如打印机资源设置为mutex1，摄像头资源设置为mutex2。
2.P、V操作必须成对出现。缺少P(mutex)就不能保证临界资源的互斥访问。缺少V(mutex)会导致资源永不被释放，等待进程永不被唤醒。
3.信号量机制实现进程同步
进程同步就是要让各并发进程按要求有序地推进。例如，下图中P1、P2并发执行，由于存在异步性，因此二者交替推进的次序是不确定的。
若 P2的“代码4”要基于 P1的“代码1”和“代码2”的运行结果才能执行，那么我们就必须保证“代码4”一定是在“代码2”之后才会执行。这就是进程同步问题，让本来异步并发的进程互相配合，有序推进。
实现步骤如下：
1.分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行的两个操作(或两句代码)
2.设置同步信号量S,初始为03.在“前操作”之后执行 V(S)
4.在“后操作”之前执行 P(S)
注意这里是前V后P，由于刚开始信号量为0，需要先V(s)，释放资源，后P(S）才能申请到该资源。
假设刚开始P1上处理机运行，先执行到 V(S)操作，则 S++后 S=1。之后当执行到 P(S)操作时，由于 S=1，表示有可用资源，会执行S--，S的值变回 0,P2进程不会执行 block 原语(即P2进程不会被阻塞)，而是继续往下执行代码4。
假设刚开始P2上处理机运行，先执行到 P(S)操作，由于S=0，S--后 S=-1，表示此时没有可用资源，因此P操作中会执行 block 原语，主动请求阻塞。之后当执行完代码2，继而执行V(S)操作，S++，使S变回 0,由于此时有进程在该信号量对应的阻塞队列中，因此会在V操作中执行 wakeup 原语，唤醒 P2进程。这样 P2 就可以继续执行 代码4 了。
总的来说，保证了代码4一定在代码2之后执行。
4.信号量机制实现前驱关系
进程 P1中有句代码S1，P2中有句代码S2，P3中有句代码S3...P6中有句代码S6。这些代码要求按如下前驱图所示的顺序来执行:
其实每一对前驱关系都是一个进程同步问题(需要保证一前一后的操作),即每一条线都代表一前一后地同步问题。
因此:
1.要为每一对前驱关系各设置一个同步信号量，并且设置为0
2.在“前操作”之后对相应的同步信号量执行V操作
3.在“后操作”之前对相应的同步信号量执行P操作
对应的代码如下：
