# 进程同步、互斥
# 进程同步
同步亦称直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而产生制约关系。进程间的直接制约关系就是源自于它们之间的相互合作
# 进程互斥
我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备 (比如摄像头、打印机) 都属于临界资源。此外还有许多变量、数据、内存缓冲区都属于临界资源
对临界资源的访问，必须互斥地进行。互斥，亦称间接制约关系。进程互斥指当一个进程访问某种临界资源时，另一个想要访问临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源后，另一个进程才能去访问临界资源。
对临界资源的访问，可以在逻辑上分为四个部分：
- 进入区：负责检查是否可进入临界区，若可进入，则应设置正在访问临界资源的标志 (可理解为上锁)，以阻止其他进程同时进入临界区
- 临界区：访问临界资源的那段代码
- 退出区：负责解除正在访问临界资源的标志 (可理解为解锁)
- 剩余区：做其他处理
注意：
- 临界区是进程中访问临界资源的代码段
- 进入区和退出区是负责实现互斥的代码段
- 临界区也可称为 "临界段"
为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则：
- 空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区
- 忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待
- 有限等待。对请求访问的进程，应保证能在有限时间内进入临界区 (保证不会饥饿)
- 让权等待。对进程不能进入临界区时，应立即释放处理机，防止进程忙等待
# 进程互斥的软件实现方法
# 单标志法
算法思想：两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予
例如：
int turn=0; //turn表示当前允许进入临界区的进程号
P0进程：
while(turn!=0); //进入区
critical section; //临界区
turn=1; //退出区
remainder section; //剩余区
P1进程：
while(turn!=1); //进入区
critical section; //临界区
turn=0; //退出区
remainder section; //剩余区
该算法可以实现 "同一时刻最多只允许一个进程访问临界区"
单标志法存在的主要问题是：违背 "空闲让进" 原则
# 双标志先检查法
算法思想：设置一个布尔型数组 flag []，数组中各个元素用来标志各进程想进入临界区的意愿，比如 "flag [0]=true" 意味着 0 号进程 P0 现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把有自身对应的标志 flag [i] 设为 true，之后开始访问临界区。
bool flag[2]; //表示进入临界区意愿的数组
flag[0]=false;
flag[1]=false; //刚开始设置为两个进程都不进入临界区
P0进程：
while(flag[1]);
flag[0]=true;
critical section;
flag[0]=false;
remainder section;
P1进程：
while(flag[0]); //如果此时P0进入临界区，P1就循环等待
flag[1]=true; //标记为P1进程想要进入临界区
critical section; //访问临界区
flag[1]=false; //访问完临界区，修改标记为P1不想使用临界区
remainder section;
两个进程可能会同时进入临界区
双标志先检查法的主要问题是：违反 "忙则等待" 原则
原因在于，进入区的 "检查" 和 "上锁" 两个处理不是一气呵成的。检查后，上锁前可能发生进程切换
# 双标志后检查法
算法思想：双标志先检查法的改版。前一个算法的问题是先 "检查" 后 "上锁"，但是这两个操作又无法一气呵成，因此导致了两个进程同时进入临界区的问题。因此，人们又想到先 "上锁" 后检查的方法，来避免上述问题
bool flag[2]; //表示进入临界区意愿的数组
flag[0]=false;
flag[1]=false; //刚开始设置为两个进程都不进入临界区
P0进程：
flag[0]=true;
while(flag[1]);
critical section;
flag[0]=false;
remainder section;
P1进程：
flag[1]=true; //标记为P1进程想要进入临界区
while(flag[0]); //如果此时P0进入临界区，P1就循环等待
critical section; //访问临界区
flag[1]=false; //访问完临界区，修改标记为P1不想使用临界区
remainder section;
P0 和 P1 将都无法进入临界区
因此，双标志后检查法虽然解决了 "忙则等待" 的问题，但是又违背了 "空闲让进" 和 "有限等待" 原则，会因各进程都长期无法访问临界资源而产生 "饥饿" 现象
# Peterson 算法
算法思想：结合双标志法、单标志法的思想。如果双方都争着想进入临界区，那可以让进程尝试谦让
bool flag[2]; //表示进入临界区意愿的数组，初始值都是false
int turn=0; //turn 表示优先让哪个进程进入临界区
P0进程：
flag[0]=true;
turn=1;
while(flag[1] && turn==1);
critical section;
flag[0]=false;
remainder section;
P1进程：
flag[1]=true; //表示自己想进入临界区
turn = 0; //可以优先让对方进入临界区
while(flag[0] && turn==0); //对方想进，且最后一次是自己"谦让"，那自己就循环等待
critical section;
flag[1]=false; //访问完临界区，表示自己已经不想访问临界区了
remainder section;
Peterson 算法用软件方法解决了进程互斥问题，遵循了空闲让进、忙则等待、有限等待三个原则，但是依然未遵循让权等待的原则
# 进程互斥的硬件实现方法
# 中断屏蔽方法
利用 "开 / 关中断指令" 实现 (与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况)
关中断后即不允许当前进程被中断，也必然不会发生进程切换
直到当前进程访问完临界区，再执行开中断指令，才有可能有别的进程上处理机并访问临界区
优点：简单、高效
缺点：不适用于多处理机，只适用于操作系统内核进程，不适用于用户进程 (因为开 / 关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险)
# TestAndSet 指令
简称 TS 指令，也有地方称为 TestAndSetLock 指令，或 TSL 指令
TSL 指令是用硬件实现额，执行的过程不允许被中断，只能一气呵成。以下是用 C 语言描述的逻辑
//布尔型共享变量lock表示当前临界区是否被加锁
//true表示已加锁，false表示未加锁
bool TestAndSet(bool *lock){
bool old;
old = *lock; //old用来存放lock原来的值
*lock = true; //无论之前是否已加锁，都将lock设为true
return old; //返回lock原来的值
}
//以下是使用TSL指令实现互斥的算法逻辑
while(TestAndSet(&lock)); //"上锁"并检查
critical section;
lock = false; //解锁
remainder section;
相比软件实现方法，TSL 指令把上锁和检查操作用硬件的方式变成了一气呵成的原子操作。
优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞，适用于多处理机环境
缺点：不满足 "让权等待" 原则，暂时无法进入临界区的进程会占用 CPU 循环执行 TSL 指令，从而导致忙等
# Swap 指令
Swap 指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是 C 语言描述的逻辑
//Swap指令的作用是交换两个变量的值
Swap(bool *a,bool *b){
bool temp;
temp=*a;
*a=*b;
*b=temp;
}
//以下是Swap指令实现互斥算法的逻辑
//lock表示当前临界区是否被加锁
bool old=true;
while(old == true)
Swap(&lock,&old);
critical section;
lock = false;
remainder section;
优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞，适用于多处理机环境
缺点：不满足 "让权等待" 原则，暂时无法进入临界区的进程会占用 CPU 循环执行 TSL 指令，从而导致忙等
# 互斥锁
互斥锁
解决临界区最简单的工具就是互斥锁，一个进程在进入临界区时应获得锁；在退出临界区时释放锁。
互斥锁的主要缺点是忙等待，当有一个进程在临界区中，任何其他进程在进入临界区时必须连续循环调用获得锁函数。当多个进程共享同一 CPU 时，就浪费了 CPU 周期。因此互斥锁通常用于多处理系统，一个线程可以在一个处理器上等待，不影响其他线程的执行
需要连续循环忙等的互斥锁，都可称为自旋锁，如 TSL 指令，Swap 指令，单标志法
锁的特性
- 需忙等，进程时间片用完才下处理机，违反 "让权等待"
- 优点：等待期间不用切换进程上下文，多处理器系统中，若上锁的时间短，则等待代价很低
- 常用于多处理器系统，一个核忙等，其他核照常工作，并快速释放临界区
- 不太适用于单处理机系统，忙等的过程中不可能解锁
# 信号量机制
用户进程可以通过操作系统提供的一对原语对信号量进行操作，从而很方便的实现了进程互斥、进程同步
信号量其实就是一个变量（可以是一个整数，也可以是更复杂的记录型变量），可以用一个信号量来表示系统中某种资源的数据。
原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。原语是由关中断 / 开中断指令实现的。
一对原语：wait (S) 原语和 signal (S) 原语
wait，signal 称为 P、V 操作
# 整形信号量
用一个整形变量作为信号量，用来表示系统中某种资源的数量
- 与普通变量的区别：对信号量的操作只有三种，即初始化，P 操作，V 操作
void wait(int S){
while(S<=0);
S=S-1;
}
void signal(int S){
S=S+1;
}
进程Pn
wait(S);
使用临界资源
signal(S);
# 记录型信号量
整形信号量的缺陷是存在 "忙等" 问题，记录型信号量就是用记录型数据结构表示的信号量
//记录型信号量的定义
typedef struct {
int value; //剩余资源数
struct process *L; //等待队列
} semaphore;
//某进程需要使用资源时，通过wait原语申请
void wait(semaphore S){
S.value--;
if(S.value<0){
block(S.L); //如果剩余资源数不够，使用block原语使进程从运行态进入阻塞态，并挂到信号量S的等待队列（即阻塞队列）中
}
}
//进程使用完成后，通过signal原语释放
void signal(semaphore S){
S.value++;
if(S.value<=0){ //释放资源后，若还有别的进程在等待这种资源，则使用wakeup原语唤醒等待队列中的一个进程，该进程从阻塞态变为就绪态
wakeup(S.L);
}
}
对信号量 S 的一次 P 操作意味着进程请求一个单位的该类资源，因此需要执行 S.value--，表示资源数减 1，当 S.value<0 表示资源已分配完毕，因此进程应调用 block 原语进行自我阻塞（当前运行的进程从运行态 -> 阻塞态），主动放弃处理机，并插入该类资源的等待队列 S.L 中。可见，该机制遵循了 "让权等待" 的原则，不会出现忙等的现象
对信号量 S 的一次 V 操作意味着进程释放一个单位的该类资源，因此需要执行 S.value++，表示资源数加 1，若加 1 后仍是 S.value<=0 表示仍有进程在等待该类资源，因此进程应调用 wakeup 原语唤醒等待队列中的第一个进程（被唤醒进程从阻塞态 -> 就绪态）。
# 用信号量机制实现进程互斥、同步、前驱关系
# 实现进程互斥
- 分析并发进程的关键活动，划定临界区
- 设置互斥信号量 mutex（进入临界区的名额），初始值为 1
- 在进入区 P (mutex)—— 申请资源
- 在退出区 V (mutex)—— 释放资源
注意：对不同的临界资源需设置不同的互斥信号量
P、V 操作必须成对出现。缺少 P (mutex) 就不能保证临界资源的互斥访问，缺少 S (mutex) 会导致资源永不被释放。等待进程永不被唤醒
# 实现进程同步
进程同步：要让各进程按要求有序地推进
用信号量实现进程同步：
- 分析什么地方需要实现 "同步关系"，即必须保证 "一前一后" 执行的两个操作
- 设置同步信号量 S，初始为 0
- 在 "前操作" 之后执行 V (S)
- 在 "后操作" 之后执行 P (S)
# 实现前驱关系
每一对前驱关系都是一个进程同步问题 (需要保证一前一后操作)
- 要为每一对前驱关系各设置一个同步信号量
- 在 "前操作" 之后对相应的同步信号量执行 V 操作
- 在 "后操作" 之前对相应的同步信号量执行 P 操作
PV 操作题目分析步骤
- 关系分析。找出题目中描述的各个进程。分析它们之间的同步、互斥关系
- 整理思路。根据各进程的操作流程确定 P、V 操作的大致顺序
- 设置信号量。并根据题目条件确定信号量初值。(互斥信号量初值一般为 0，同步信号量的初始值要看对应资源初始值为多少)
# 生产者消费者问题
问题描述
系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用 (注：这里的 "产品" 可理解为数据)
生产者、消费者共享一个初始为空、大小为 n 的缓冲区。
只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待、
分析解答
- 缓冲区没满 -> 生产者生产
- 缓冲区没空 -> 消费者消费
- 缓冲区满 -> 生产者等待
- 缓冲区空 -> 消费者等待
semaphore mutex = 1; //互斥信号量，实现对缓冲区的互斥访问
semaphore empty = n; //同步信号量，表示空闲缓冲区的数量
semaphore full = 0; //同步信号量，表示产品的数量，也即非空缓冲区的数量
producer() {
while(1){
生产一个产品;
P(empty); //消耗一个空闲缓冲区
P(mutex); //同一进程中的互斥操作
把产品放入缓冲区;
V(mutex);
V(full); //增加一个产品
}
}
consumer() {
while(1){
P(full); //消耗一个产品(非空缓冲区)
P(mutex);
从缓冲区中取走一个产品;
V(mutex);
V(empty); //产生一个空闲缓冲区
使用产品
}
}
改变 P、V 顺序可能会导致死锁，因此，实现互斥的 P 操作一定要在实现同步的 P 操作之后，V 操作不会导致进程阻塞，因此两个 V 操作顺序可以交换
# 多生产者 - 多消费者问题
问题描述
桌子上有一只盘子，每次只能向其中放入一个水果，爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专等着吃盘子中的橘子，女儿专等着吃盘子中的苹果，仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出水果。用 PV 操作实现上述过程
分析解答
互斥关系：对缓冲区 (盘子) 的访问要互斥地进行
同步关系：
- 父亲将苹果放入盘子后，女儿才能取苹果
- 母亲将橘子放入盘子后，儿子才能取橘子
- 只有盘子为空时，父亲或母亲才能往盘子里放水果
semaphore mutex = 1; //实现互斥访问盘子(缓冲区)，这一个信号量可以不需要
semaphore apple = 0; //盘子里有几个苹果
semaphore orange = 0; //盘子里有几个橘子
semaphore plate = 1; //盘子中还可以放多少水果
dad(){
while(1){
准备放一个苹果;
P(plate);
把苹果放入盘子;
V(apple);
}
}
mom(){
while(1){
准备放一个句子;
P(plate);
把橘子放入盘子;
V(orange);
}
}
daughter(){
while(1){
P(apple);
从盘子中取出苹果;
V(plate);
吃掉苹果;
}
}
son() {
while(1){
P(orange);
从盘子中取出橘子;
V(plate);
吃掉橘子;
}
}
结论：在生产者 - 消费者问题中，如果缓冲区大小为 1，那么有可能不需要设置互斥信号量就可以实现互斥访问缓冲区的功能。当然，这不是绝对的，要具体情况具体分析。当缓冲区大小大于 1 是，就必须设置互斥信号量保证互斥访问缓冲区
# 吸烟者问题
问题描述
假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽调一支烟，抽烟者需要三种材料：烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放到桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者就会放另外两种材料在桌上，这个过程一直重复 (让三个抽烟者轮流抽烟)
分析解答
同步关系：
- 桌子上有组合一 -> 第一个抽烟者取走东西
- 桌子上有组合二 -> 第二个抽烟者取走东西
- 桌子上有组合三 -> 第三个抽烟者取走东西
- 发出完成信号 -> 供应者将下一个组合放到桌子上
semaphore offer1 = 0; //桌子上有组合一的数量
semaphore offer2 = 0; //桌子上有组合二的数量
semaphore offer3 = 0; //桌子上有组合三的数量
semaphore finish = 0; //抽烟是否完成
int i=0; //用于实现三个抽烟者轮流抽烟
provider(){
while(1){
if(i==0){
将组合一放在桌子上;
V(offer1);
} else if (i==1){
将组合二放在桌子上;
V(offer2);
} else if(i==2){
将组合三放在桌子上;
V(offer3);
}
i=(i+1)%3;
P(finish);
}
}
smoker1(){
while(1){
P(offer1);
从桌子上拿走组合一，卷烟，抽掉;
V(finish);
}
}
smoker2(){
while(1){
P(offer2);
从桌子上拿走组合二，卷烟，抽掉;
V(finish);
}
}
smoker3(){
while(1){
P(offer3);
从桌子上拿走组合三，卷烟，抽掉;
V(finish);
}
}
# 读者写者问题
问题描述
有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时，不会产生副作用，但若是某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。因此要求：①允许多个读者可以同时对文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作之前不允许其他读者或写者工作；④写者执行写操作前，应让已有的读者和写者全部退出。
分析解答
semaphore rw = 1; //用于实现对共享文件的互斥访问
int count=0; //记录当前有几个读进程在访问文件
semaphore mutex = 1; //用于保证对count变量的互斥访问
writer(){
while(1){
P(rw); //写之前加锁
写文件;
P(rw);
}
}
reader(){
while(1){
P(mutex); //各读进程互斥访问counter
if(count==0) //由第一个读进程负责
P(rw); //读之前加锁
count++;
V(mutex);
读文件;
P(mutex); //各读进程互斥访问count
count--;
if(count==0) //由最后一个读进程负责
V(rw); //读完了解锁
V(mutex);
}
}
潜在的问题：只要有读进程还在读，写进程就要一直阻塞等待，可能饿死，因此，这种算法中，读进程是优先的
改为写优先：
semaphore rw = 1; //用于实现对共享文件的互斥访问
int count=0; //记录当前有几个读进程在访问文件
semaphore mutex = 1; //用于保证对count变量的互斥访问
semaphore w = 1; //用于实现写优先
writer(){
while(1){
P(w);
P(rw); //写之前加锁
写文件;
P(rw);
V(w);
}
}
reader(){
while(1){
P(w);
P(mutex); //各读进程互斥访问counter
if(count==0) //由第一个读进程负责
P(rw); //读之前加锁
count++;
V(mutex);
V(w);
读文件;
P(mutex); //各读进程互斥访问count
count--;
if(count==0) //由最后一个读进程负责
V(rw); //读完了解锁
V(mutex);
}
}
结论：在这种算法中，连续进入的多个读者可以同时读文件，写者和其他进程不能同时访问文件；写者不会饥饿，但也并不是真正的写优先，而是相对公平的先来先服务原则
核心思想：设置了一个计数器 count 用来记录当前正在访问共享文件的读进程数。我们可以用 count 的值判断当前进入的进程是否是第一个 / 最后一个读进程，从而做出不同的处理
# 哲学家进餐问题
问题描述
一个圆桌上坐着 5 名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当前哲学家饥饿时，才试图拿起左、右两根筷子 (一根一根地拿起)。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。
分析解答
- 关系分析。系统中 5 位哲学家进程，5 位哲学家与左右邻居对其中间的筷子访问是互斥关系的
- 信号量设置。定义互斥信号量数组 chopstick [5]={1,1,1,1,1} 用于实现对 5 个筷子的互斥访问。并对哲学家按 0~4 编号，哲学家 i 左边的筷子编号为 i，右边快字的编号为 (i+1)%5
semaphore chopstick[5]={1,1,1,1,1};
Pi(){ //第i号哲学家的进程
while(1){
P(chopstick[i]); //拿起左边的筷子
P(chopstick[(i+1)%5]); //拿起右边的筷子
吃饭;
V(chopstick[i]); //放左
V(chopstick[(i+1)%5]); //放右
思考;
}
}
上述方式可能会导致每个哲学家都拿起了左边的筷子，但是都在等待右边的筷子，造成死锁
解决方式：
可以对哲学家进程施加一些限制条件，比如最多允许四个哲学家同时进餐。这样可以保证至少一个哲学家是可以拿到左右两只筷子的
要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反，用这种方法可以保证如果两个相邻的奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况
仅当一个哲学家两只筷子都可用时才允许他抓起筷子
改进后的程序：
semaphore chopstick[5]={1,1,1,1,1};
semaphore mutex = 1; //互斥地取筷子
Pi(){ //第i号哲学家的进程
while(1){
P(mutex);
P(chopstick[i]); //拿起左边的筷子
P(chopstick[(i+1)%5]); //拿起右边的筷子
V(mutex);
吃饭;
V(chopstick[i]); //放左
V(chopstick[(i+1)%5]); //放右
思考;
}
}
上面这种办法并不能保证只有两边的筷子都可用时，才允许哲学家拿起筷子。但这种方法不会造成死锁，可以解决问题。
# 管程
管程是一种特殊的软件模块，有这些部分组成：
- 局部于管程的共享数据结构说明；
- 对该数据结构进行操作的一组过程
- 对局部于管程的共享数据设置初始值的语句
- 管程有一个名字
管程的基本特征：
- 局部于管程的数据只能被局部于管程的过程所访问
- 一个进程只有通过调用管程内的过程才能进入管程访问共享数据
- 每次仅允许一个进程在管程内执行某个内部过程
拓展 1：用管程解决生产者消费者问题：
monitor ProducerConsumer
condition full,empty; //条件变量用来实现同步(排队)
int count=0; //缓冲区中的产品数
void insert(Item item){ //把产品item放入缓冲区
if(count==N)
wait (full);
count++;
insert_item(item);
if(count==1)
signal(empty);
}
Item remove(){ //从缓冲区中取出一个产品
if(count ==0)
wait(empty);
count--;
if(count==N-1)
signal(full);
return remove_item();
}
end monitor;
//生产者进程
producer(){
while(1){
item = 生产一个产品;
ProducerConsumer.insert(item);
}
}
//消费者进程
consumer(){
while(1){
item = ProducerConsumer.remove();
消费产品item;
}
}
引入管程的目的无非就是更方便地实现进程互斥和同步
- 需要在管程中定义共享数据（如生产者消费者的缓冲区）
- 需要再管程中定义用于访问这些共享数据的 "入口"—— 其实就是一些函数 (如生产者消费者问题中，可以定义一个函数用于将产品放入缓冲区，再定义一个函数用于从缓冲区取出产品)
- 只有通过这种特定的入口才能访问共享数据
- 管程中有很多入口，但是每次只能开放其中一个入口，并且只能让一个进程或线程进入（如生产者消费者问题中，各进程需要互斥地访问共享缓冲区。管程的这种特性即可保证一个时间段内最多只会有一个进程在访问缓冲区。注意：这种互斥特性是由编译器负责实现的，程序员不用关心）
- 可在管程中设置条件变量及等待 / 唤醒操作以解决同步问题。可以让一个进程或线程在条件变量上等待 (此时，该进程应先释放管程的使用权，也就是让出入口)；可以通过唤醒操作将等待在条件变量上的进程或线程唤醒。
