进程/线程的互斥与同步
进程同步与互斥
进程具有异步性的特征。异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进
读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执行的先后顺序是不确定的。
而实际应用中，又必须按照“写数据 --> 读数据”的顺利来执行的
如何解决这种异步问题，就是进程同步所讨论的内容
同步亦称 直接制约关系 \textcolor{red}{直接制约关系} 直接制约关系
它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而产生的制约关系。进程间的制约关系就是源于它们之间的相互合作
什么是进程互斥
进程的”并发“需要”共享“的支持。
各个并发执行的进程不可避免地需要共享一些系统资源（比如内存，又比如打印机、摄像头这样的 I / O I\ / \ O I / O 设备）
我们把 一个时间段只允许一个进程使用 \textcolor{red}{一个时间段只允许一个进程使用} 一个时间段只允许一个进程使用的资源称为 临界资源 \textcolor{red}{临界资源} 临界资源。
许多物理设备（比如摄像头、打印机）都属于临界资源
此外还有许多变量、数据、内存缓冲区等都属于临界资源
对临界资源的访问，必须 互斥 \textcolor{red}{互斥} 互斥地进行。
互斥，亦称为简介制约关系。
进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源地进程必须等待。
当前访问临界资源地进程访问结束，释放该资源之后，另一个进程才能去访问该临界资源
临界区
临界区是进程中访问临界资源的代码段
进入区和退出区是负责实现互斥的代码段
临界区也可以称为”临界段“
为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则
- 空闲让进：临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区
- 忙则等待：当已有进程进入临界区时，其他试图进入临界区的进程必须等待
- 有限等待：对请求访问的进程，应保证能在有限时间进入临界区（保证不会饥饿）
- 让权等待：当进程不能进入临界区时，应立即释放处理机，防止进程忙等待
进程互斥的软件实现方法
单标志法
算法思想：两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。
也就是说每个进程进入临界区的权限只能被另一个进程赋予
int turn = 0; //turn表示当前允许进入临界区的进程号
//P0 进程
while(turn != 0) {
critical section;
turn = 1;
remainder section;
}
//P1 进程
while(turn != 0) {
critical section;
turn = 1;
remainder section;
}
turn的初值为0，即刚开始只允许0号进程进入临界区
若P1先上处理机运行，则会一直卡在第11行代码。直到P1的时间片用完，发生调度，切换P0上处理机运行。
第4行代码不会卡住P0，P0可以正常访问临界区，在P0访问临界区期间即使切换回P1，P1依然会卡在第11行代码。
只有P0在退出区将turn改为1后，P1才能进入临界区。
因此，该算法可以实现同一时间最多只允许一个进程访问临界区
单标志法存在的主要问题是：违背”空闲让进“原则
双标志先检查法
算法思想：设置一个布尔类型数组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;
reminder section;
//P1进程
while(flag[0]);
flag[1] = true;
critical section;
flag[1] = false;
reminder section;
双标志先检查法的主要问题是：违反”忙则等待“原则
原因在于，进入区的”检查“和”上锁“两个处理不是一气呵成的。”检查“后，”上锁“前可能发生进程切换
双标志后检查法
算法思想：双标志先检查法的改版。前一个算法的问题是先”检查“后”上锁“，但是这两个操作又无法一气呵成，因此
导致了两个进程同时进入临界区的问题。
因此，人们又想到先”上锁“后”检查“的方法来避免上述问题
bool flag[2];
flag[0] = false;
flag[1] = false;
//P0进程
flag[0] = true;
while(flag[1]);
critical section;
flag[0] = false;
reminder section;
//P1进程
flag[1] = true;
while(flag[0]);
critical section;
flag[1] = false;
reminder section;
虽然解决了忙则等待的问题，但是又违背了”空闲让进“和”有限等待“原则/font>，会因各进程都长期无法访问临界资源而产生产生”饥饿“现象
两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区
Peterson算法
算法思想：结合双标志法、单标志法的思想。
如果双方都争着想进入临界区，那可以让进程尝试谦让
bool flag[2];
flag[0] = false;
flag[1] = false;
int turn = 0; //turn表示优先让哪个进程进入临界区
//P0进程
flag[0] = true;
turn = 1;
while(flag[1] && turn == 1);
critical section;
flag[0] = false;
reminder section;
//P1进程
flag[1] = true;
turn = 0;
while(flag[0] && turn == 0);
critical section;
flag[1] = false;
reminder section;
”谁最后谦让谁就后进入临界区“
Peterson算法虽然用软件方法解决了进程互斥问题，遵循了空闲让进、忙则等待、有限等待三个原则，但是依然未遵循让权等待的原则
进程互斥的硬件实现方法
中断屏蔽方法
利用”开/关中断指令“实现（与原语的实现思想相同，即在某个进程开始访问临界区到结束访问为止都不允许被中断
也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况）
...
关中断; //关中断后即不允许当前进程被中断，也必然不会发生进程切换
临界区;
关中断; //直到当前进程访问完临界区，再执行开中断指令，才有可能有别的进程上处理机并访问临界区
...
优点：简单、高效
缺点：不适用于多处理机；只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能在内核态，这组指令如果能让用户随意使用会很危险）
TestAndSet指令
简称TS指令，也有地方称为TestAndSetLock指令，或TSL指令
TSL指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是C语言代码描述的逻辑
//布尔型共享变量lock表示当前临界区是否加锁
//true表示已加锁，false表示未加锁
bool TestAndSet(bool *lock) {
bool old;
old = *lock;
*lock = true;
return old;
}
//以下是使用TSL指令实现互斥的算法逻辑
while(TestAndSet(&lock)) { //检查并上锁
临界区代码...
lock = false; //”解锁“
剩余区代码...
}
优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境
缺点：不满足”让权等待“原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致”忙等“
Swap指令
Swap指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。
//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);
临界区代码段...
lock = false;
剩余区代码段...
}
逻辑上看Swap和TSL并无太大区别，都是先记录下此时临界区是否已经被上锁（记录在old变量上），再将上锁标志lock设置为true，最后检查old，如果old为false则说明之前没有别的进程对临界资源上锁，则可能跳出循环，进入临界区
优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境
缺点：不满足”让权等待“原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致”忙等“
互斥锁
解决临界区最简单的工具就是互斥锁（mutex lock）。一个进程在进入临界区时应获得锁；在退出临界区时释放锁。函数acquire()获得锁，而函数release()释放锁
每个互斥锁有一个不良变量avaiable，表示锁是否可用。如果锁是可用的，调用acqiure()会成功，且锁不再可用。当一个进程试图获取不可用的锁的时候，会被阻塞，直到锁被释放
acquire() {
while(!available); //忙等待
available = false; //获得锁
}
release() {
available = true; //释放锁
}
acquire()和release()的执行必须是原子操作，因此互斥锁通常采用硬件机制来实现
互斥锁的主要缺点是忙等待，当有一个进程在临界区中，任何其他进程在进入临界区时必须连续循环调用acquire()。
当多个进程共享同一CPU时，就浪费了CPU周期。因此，互斥锁通常用于多处理器系统，一个线程可以在一个处理器上等待，不影响其他其他线程的执行
需要连续循环忙等的互斥锁，都可称为自旋锁，如TSL指令、Swap指令、单标志法
特性：
- 需忙等，进程时间片用完才下处理机，违反”让权等待“
- 优点：等待期间不用切换进程上下文，多处理器系统中，若上锁的时间短，则等待代价很低
- 常用于多处理器系统，一个核忙等，其他核照常工作，并且快速释放临界区
- 不太适用于单处理机系统，忙等的过程中不可能解锁
信号量机制
用户之间可以通过使用操作系统提供的一堆原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。
信号量其实就是一个变量（可以是一个整数，也可以是更复杂的记录型变量），可以用一个信号量来表示系统中某种资源的数量，
比如：系统中只有一台打印机，就可以设置一个初值为1的信号量
一对原语：wait(S)原语和signal(S)原语，可以把原语理解为我们自己写的函数，函数名分别为wait和signal，括号里的
信号量S其实就是函数调用时传入的一个参数
wait、signal原语常简称P、V操作
整形信号量
用一个整数型的变量作为信号量，用来表示系统中某种资源的数量
int S = 1; //初始化整型信号量S，表示当前系统中可用的打印机资源
void wait(int S) { //wait原语，相当于”进入区“
while(S <= 0); //如果资源数不够，就一直循环等待
S = S - 1; //如果资源数够，则占用一个资源
}
void signal(int S) { //signal原语，相当于”退出区“
S = S + 1; //使用完资源后，在退出区释放资源
}
记录型信号量
整型信号量的缺陷是存在“忙等“问题，因此人们又提出了”记录型信号量“，即用记录型数据结构表示的信号量
//记录型信号量的定义
typedef struct {
int value; //剩余资源数
struct process *L; //等待队列
} semaphore;
PV操作这对原语可用于实现系统资源的”申请“和”释放“。
S.value的初值表示系统中某种资源的数目
//某进程需要使用资源时，通过wait原语申请
void wait(semaphore S) {
S.value--;
if (S.value < 0) {
block(S.L); //如果剩余资源数不够，使用block原语使进程从运行态进入阻塞态
} //并把挂到信号量S的等待队列（即阻塞队列）中
}
对信号量S的一次P操作意味着进程请求一个单位的该类资源，因此需要执行S.value--，表示资源数减1，当
S.value < 0 时表示该类资源已分配完毕，因此此进程应调用block原语进行自我阻塞当前运行的进程从运行 --> 阻塞）
主动放弃处理机，并插入该类资源的等待队列S.L中。可见，该机制遵守了”让权等待“原则，不会出现”忙等“现象
//进程使用完资源后，通过signal原语释放
void signal(semaphore S) {
s.value++;
if (S.value <= 0) {
wakeup(S.L); //释放资源后，若还有别的进程在等待这种资源，则使用wakeup原语唤醒队列中的一个进程
} //该进程从阻塞态变成就绪态
}
对信号量S的一次V操作意味着进程释放一个单位的该类资源，因此需要执行S.value++，表示资源数加1，若加1后仍是
S.value <= 0，表示依然有进程在等待该类资源
因此应调用wakeup原语唤醒等待队列中的第一各进程（被唤醒进程从阻塞态 --> 就绪态）
用信号量实现进程互斥、同步、前驱关系
实现进程互斥
- 分析并发进程的关键活动，划定临界区（如：对临界资源打印机的访问就应放在临界区）
- 设置互斥信号量mutex，初值为1
- 在进入区——申请资源
- 在退出区——释放资源
注意：对不同的临界资源需要设置不同的互斥信号量，P、V操作必须成对出现，缺少P(mutex)就不能保证临界资源的互斥访问
缺少V(mutex)会导致资源永不被释放，等待进程永不被唤醒
信号量机制实现同步
进程同步：要让各并发进程按要求有序地推进
用信号量实现进程同步：
- 分析什么地方需要实现”同步关系“，即必须保证”一前一后“执行的两个操作（或两句代码）
- 设置同步信号量S，初始值为0
- 在”前操作“之后执行V(S)
- 在”后操作“之前执行P(S)
技巧口诀：前V后P
生产者消费者问题
系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品并使用
（注：这里的”产品“理解为某种数据）
生产者、消费者共享一个初始为空、大小为n的缓冲区
只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待（缓冲区没满 --> 生产者生产）
只有缓冲区不空时，消费者才能从中取出产品，否则必须等待（缓冲区没空 --> 消费者消费）
缓冲区是临界资源，各进程必须互斥地访问（互斥关系）
semaphore mutex = 1; //互斥信号量，实现对缓冲区的互斥访问
semaphore empty = n; //同步信号量，表示空闲缓冲区的数量
semaphore full = 0; //同步信号量，表示产品的数量，也即非空缓冲区的数量
producer() {
while(1) {
生产一个产品;
P(empty); //消耗一个空闲缓冲区
P(mutex); //实现互斥是在同一进程中进行一对PV操作
把产品放入缓冲区;
V(mutex);
V(full); //增加一个产品
}
}
consumer() {
while(1) {
P(full); //消耗一个产品（非空缓冲区）
P(mutex);
从缓冲区取出一个产品;
V(mutex);
V(empty); //增加一个空闲缓冲区
使用产品;
}
}
能否改变相邻P、V操作的顺序
producer() {
while(1) {
生产一个产品;
P(mutex);
P(empty);
把产品放入缓冲区;
V(mutex);
V(full);
}
}
consumer() {
while(1) {
P(mutex);
P(full);
从缓冲区取出一个产品;
V(mutex);
V(empty);
使用产品;
}
}
若此时缓冲区内已经放满产品，则empty = 0，full = n。
则生产者进程执行第四行代码使mutex变为0，再执行第五行代码，由于已经没有空闲缓冲区，因此生产者被阻塞。
由于生产者阻塞，因此切换回消费者进程。消费者进程执行第14行代码，由于mutex为0，即生产者还没释放对临界资源的”锁“
因此消费者也被阻塞。
这就造成了生产者等待消费者释放空闲缓冲区，而消费者又等待生产者释放临界区的情况，生产者和消费者循环等待被对方唤醒，出现死锁
实现互斥的P操作一定要咋i实现同步的P操作之后
V操作不会导致进程阻塞，因此两个V操作顺序可以交换
吸烟者问题
假设一个系统中有三个抽烟者进程和一个供应者线程。
每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料：烟草、纸和胶水。
三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次
将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者
就会放另外两种材料在桌上，这个过程一直重复（让三个抽烟者轮流地抽烟）
桌子可以抽象为容量为1的缓冲区，要互斥访问
semaphore offer1 = 0; //桌上组合一的数量
semaphore offer2 = 0; //桌上组合三的数量
semaphore offer3 = 0; //桌上组合三的数量
semaphore finish = 0; //用于实现“三个抽烟者轮流地抽烟”
provider() {
if (i == 0) {
将组合一放桌上;
V(offer1);
} else if(i == 1) {
将组合二放桌上;
V(offer2);
} else if (i == 2) {
将组合三放桌上;
V(offer3);
}
i = (i + 1) % 3;
P(finish);
}
smoker1() {
P(offer1);
从桌上拿走组合一卷烟抽掉;
V(finish);
}
smoker2() {
P(offer2);
从桌上拿走组合二卷烟抽掉;
V(finish);
}
smoker3() {
P(offer3);
从桌上拿走组合三卷烟抽掉;
V(finish);
}
吸烟者问题可以为我们解决“可以生产多个产品的单生产者”问题提供一个思路
读者写者问题
有读者和写者两组并发进程，共享一个文件，当两个或两个以上的读进程同时访问共享数据时不会产生副作用，
但若某个写者进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。
因此要求：
- 允许多个读者可以同时对文件执行读操作
- 只允许一个写者往文件中写信息
- 任一写者在完成写操作之前不允许其他读者或写者工作
- 写者执行写操作前，应让已有的读者和写者全部退出
读进程与读进程之间不存在互斥问题
与消费者进程不同，读者进程在读数据后并不会将数据清空，并不会改变数据。
因此多个读者可同时访问共享数据
读进程与写进程同时共享数据，可能导致读出的数据不一致的问题
两个写进程同时共享数据，可能导致数据错误覆盖的问题
读者优先
semaphore wMutex; //控制写操作的互斥信号量，初始值为1
semaphore rCountMutex; //控制对rCount的互斥修改，初始值为1
int rCount = 0; //正在进行读操作的读者个数，初始化为0
//写进程
void writer() {
while(1) {
P(wMutex); //写之前“加锁”
写数据...
V(wMutex); //写之后“解锁”
}
}
//读进程
void reader() {
while(1) {
P(rCountMutex); //各读进程互斥访问rCount
if (rCount == 0) { //由第一个读进程负责读之前“加锁”
P(wMutex);
}
rCount++; //访问文件的读进程数+1
V(rCouintMutex);
读数据...
P(rCountMutex) //各读进程互斥访问rCount
rCount--; //访问文件的读进程数-1
if (rCount == 0) { //由最后一个读进程负责读完了“解锁”
V(wMutex);
}
V(rCountMutex);
}
}
潜在的问题：只要有读进程还在读，写进程就要一直阻塞等待，可能“饿死”。
因此，在这种算法中，读进程是优先的
写者优先
既然有读者优先，那自然也有写者优先
- 只要有写者准备要写入，写者应尽快执行写操作，后来的读者就必须阻塞；
- 如果有写者持续不断写入，则读者就处于饥饿；
在读者优先的基础上增加如下条件
- 信号量
rMutex：控制读者进入的互斥信号量，初始值为 1； - 写者计数
wCount：记录写者数量，初始值为 0； - 信号量
wCountMutex：控制wCount互斥修改，初始值为 1；
semaphore wMutex; //控制写者写操作的互斥信号量，初始值为1
semaphore wCountMutex //控制对wCount的互斥修改，初始值为1
semaphore rMutex //控制读者读操作的互斥信号量，初始值为1
semaphore rCountMutex; //控制对rCount的互斥修改，初始值为1
int rCount = 0; //正在进行读操作的读者个数，初始化为0
int wCount = ; //正在进行写操作的写者个数，初始化为0
//写进程
void writer() {
while(1) {
P(wCountMutex);
if (wCount == 0) { //当第一个写者进入，如果有读者则阻塞读者读操作
P(rMutex);
}
wCount++; //读者数量+1
V(wCountMutex);
P(wMutex); //写之前“加锁”，各写进程互斥
写数据...
V(wMutex); //写之后“解锁”
P(wCountMutex); //各写进程互斥访问wCount
wCount--; //写者进程数量-1
if (wCount == 0) { //没有写者了，则唤醒阻塞中的读者
V(rMutex);
}
V(wCountMutex);
}
}
//读进程
void reader() {
while(1) {
P(rMutex);
P(rCountMutex);
if (rCount == 0) { //当第一个读者进入，如果有写者则阻塞写者的写操作
P(wMutex);
}
rCount++; //访问数据的读进程数量+1
V(rCouintMutex);
V(rMutex);
读数据...
P(rCountMutex) //各读进程互斥访问rCount
rCount--; //读者进程数量-1
if (rCount == 0) { //没有读者了，则唤醒阻塞中的写者的写操作
V(wMutex);
}
V(rCountMutex);
}
}
哲学家就餐问题
一张圆桌上坐着5名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子 (一根一根地拿起)。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。
整理思路：这个问题中只有互斥关系，但与之前遇到的问题不同的是，每个哲学家进程需要同时持有两个临界资源才能开始吃饭。
如何避免临界资源分配不当造成的 死锁现象 \textcolor{red}{死锁现象} 死锁现象，是哲学家问题的精髓。
如果5个哲学家并发地拿起了自己左手边地筷子，那么当他们尝试拿起自己右边的筷子的时候，会发现右边的筷子已经被别人占用了。
每位哲学家会循环等待右边的人放下筷子（阻塞），发生“死锁”（你们就不能用叉子或者勺子吃饭？）
如何防止死锁的发生？
- 可以对哲学家进程施加一些限制条件，比如最多允许四个哲学家同时进餐。这样可以保证至少有一个哲学家是可以拿到左右两只筷子的
- 要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么之后有其中一个可以拿起第一支筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一支的情况
- 仅当一个哲学家左右两支筷子都可用时才允许他抓起筷子
方案一
semaphore chopsticks[5]; //每个叉子一个信号量，初值为1
semaphore mutex; //互斥信号量，初值为1
void Pi() {
while(1) {
思考...
P(mutex); //互斥访问筷子
P(chopsticks[i]); //拿左边筷子
P(chopsticks[(i + 1) % 5]); //拿右边筷子
就餐...
V(chopsticks[i]); //放下左边筷子
V(chopsticks[(i + 1) % 5]); //放下右边筷子
V(mutex);
}
}
上面程序中的互斥信号量的作用就在于，只要有一个哲学家进入了「临界区」，也就是准备要拿筷子时，其他哲学家都不能动，只有这位哲学家用完筷子了，才能轮到下一个哲学家进餐。
虽然能让哲学家们按顺序吃饭，但是每次进餐只能有一位哲学家，而桌面上是有 5 支筷子，按道理是能可以有两个哲学家同时进餐的，所以从效率角度上，这不是最好的解决方案。
方案二
semaphore chopsticks[5]; //每个叉子一个信号量，初值为1
void Pi() {
while(1) {
思考...
if(i % 2 == 0) {
P(chopsticks[i]); //拿左边筷子
P(chopsticks[(i + 1) % 5]); //拿右边筷子
} else {
P(chopsticks[(i + 1) % 5]); //拿右边筷子
p(chopsticks[i]); //拿左边筷子
}
就餐...
V(chopsticks[i]); //放下左边筷子
V(chopsticks[(i + 1) % 5]); //放下右边筷子
}
}
上面的程序，在 P 操作时，根据哲学家的编号不同，拿起左右两边筷子的顺序不同。
另外，V 操作是不需要分支的，因为 V 操作是不会阻塞的。
方案三
我们用一个数组state来记录每一位哲学家的三个状态，分别是在进餐状态、思考状态、饥饿状态（正在试图拿叉子）
那么，一个哲学家只有在左右两边的人都没有进餐时，才可以进入进餐状态
第i各哲学家的左边和右边的人分别由宏L和R定义
#define N 5 //哲学家个数
#define L (i + N - 1) % N //i 号哲学家的左边的人
#define R (i + 1) % N //i 号哲学家的右边的人
#define THINK 0 //思考状态
#define HUNGRY 1 //饥饿状态
#define EATTING 2 //进餐状态
int state[N]; //数组记录每个哲学家的状态
semaphore s[5]; //每个哲学家一个信号量，初值为 0
semaphore mutex; //互斥信号量，初值为 1
void test(int i) {
//如果 i 号的左边右边哲学家都不是就餐状态，把 i 号哲学家标记为就餐状态
if (state[i] == HUNGRY && state[L] != EATTING && state[R] != EATTING) {
state[i] = EATTING; //拿到两只筷子，就餐状态
V(s[i]); //通知第 i 号哲学家可以就餐了
}
}
//要么拿到两支筷子，要么被阻塞
void take(int i) {
P(mutex); //进入临界区
state[i] = HUNGRY; //标记哲学家处于饥饿状态
test(i); //尝试获得两支筷子
V(mutex); //离开临界区
P(s[i]); //没有筷子则阻塞，有筷子则继续正常执行
}
//把两支筷子放回原处，并在需要的时候，去唤醒左右两边的人
void put(int i) {
P(mutex); //进入临界区
state[i] = THINK; //吃完饭，交出筷子，标记思考状态
test(L); //检查左边的人是否在就餐，没则唤醒
test(R); //检查右边的人是否在就餐，没则唤醒
V(mutex); //离开临界区
}
void Pi(int i) {
while(1) {
思考...
take(i); //准备拿筷子吃饭
eat(); //就餐
put(); //吃完放下筷子
}
}
上面的程序使用了一个信号量数组，每个信号量对应一位哲学家，这样在所需的筷子被占用时，想进餐的哲学家就被阻塞。
注意，每个进程/线程将 Pi 函数作为主代码运行，而其他 take、put 和 test 只是普通的函数，而非单独的进程/线程。
50
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
