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;

當四個條件全部滿足的時候，死結將有可能發生。