C语言 wait()信号量部分 signal()信号量部分代码

http://blog.csdn.net/raykid13/archive/2008/10/16/3087858.aspx

信号量结构使用C语言表示如下：

1. typedef struct {
2.     int value;//记录了这个信号量的值 
3.     struct process *list;//储存正在等待这个信号量的进程 
4. } semaphore;

wait()信号量部分代码如下：

1. wait(semaphore *S) {
2.     S->value--;
3.     if(S->value < 0) {
4.         add this process to S->list;
5.         block();
6.     }
7. }

signal()信号量部分代码如下：

1. signal(semaphore *S) {
2.     S->value++;
3.     if(S->value <= 0) {
4.         remove a process P from S->list;
5.         wakeup(P);
6.     }
7. }

一、The Bounded-Buffer Problem：

full初始化为0，empty初始化为n，mutex为1

1. do{
2.     wait(full);
3.     wait(mutex);
4.     ...
5.     //remove an item from buffer to nextc
6.     ...
7.     signal(mutex);
8.     signal(empty);
9.     ...
10.     //consume the item in nextc
11.     ...
12. } while(TRUE);

二、The Readers-Writers Problem：

wrt初始化为1，readcount初始化为0，mutex为1

写者操作：

 

1. do{
2.     wait(wrt);
3.     ...
4.     //writing is performed 
5.     ...
6.     signal(wrt);
7. } while(TRUE);

读者操作：

 

1. do{
2.     wait(mutex);//确保与signal(mutex)之间的操作不会被其他读者打断
3.     readcount++;
4.     if(readcount == 1)
5.         wait(wrt);
6.     signal(mutex);
7.     ...
8.     //reading is performed
9.     ...
10.     wait(mutex);
11.     readcount--;
12.     if(readcount == 0)
13.         signal(wrt);
14.     signal(mutex);
15. } while(TRUE);

三、The Dining-Philosophers Problem：

所有的chopstick[5]全部初始化为1

1. do{
2.     wait(chopstick[i]);
3.     wait(chopstick[(i+1)%5]);
4.     ...
5.     //eating
6.     ...
7.     signal(chopstick[i]);
8.     signal(chopstick[(i+1)%5]);
9.     ...
10.     //thinking
11.     ...
12. } while(TRUE);

但是这个解决方案的最大问题在于它会出现死锁。所以我认为应该增加一个信号量mutex，并初始化为1：

1. do{
2.     wait(mutex);
3.     wait(chopstick[i]);
4.     wait(chopstick[(i+1)%5]);
5.     signal(mutex);
6.     ...
7.     //eating  
8.     ...
9.     wait(mutex);
10.     signal(chopstick[i]);
11.     signal(chopstick[(i+1)%5]);
12.     signal(mutex);
13.     ...
14.     //thinking  
15.     ...
16. } while(TRUE);

这样由于确保了一位哲学家在拿起两只筷子的时间内其他哲学家不可以拿起任何一支筷子，从而破坏了死锁出现需要的四个特征中的Hold And Wait特征，从而避免了死锁的发生。

 

最后，死锁发生的四个特征包括：

1. Mutual exclusion;

2. Hold and wait;

3. No preemption;

4. Circular wait;

当四个条件全部满足的时候，死锁将有可能发生。