生產者消費者

記錄型信號量

//變量定義
int in=0, out=0;
item buffer[n];
semaphore mutex=l，empty=n, full=0;
 
//生產者
void proceducer(){
do{
producer an item nextp;
......
wait(empty);//等待空位子
wait(mutex);//等待緩沖池可用
buffer[in] =nextp;//設置元素
in =(in+1)%n;//下標後移
signal(mutex);//釋放緩沖池
signal(full);//“滿”也就是已生產產品個數釋放1個(+1)
}while(TRUE);
 
 
//消費者
void consumer() {
do{
wait(full);//等待已生產資源個數
wait(mutex);//等待緩沖池可用
nextc= buffer[out];//獲得一個元素
out =(out+1) % n;//下標後移
signal(mutex);//釋放緩沖池
signal(empty);//空位子多出來一個
consumer the item in nextc;//消費掉獲得的產品
} while(TRUE);
}
 
//主程序
void main() {
proceducer();
consumer();
}

AND型信號量

int in=0, out=0;
item buffer[n];
semaphore mutex=l, empty=n, full=O;
void proceducer() {
do{
producer an item nextp;
......
Swait(empty, mutex);
buffer[in] = nextp;
in =(in+1) % n;
Ssignal(mutex, full)
} while(TRUE);
}
void consumer() {
do{
Swait(full, mutex);
nextc= buffer[out];
out =(out+1) % n;
Ssignal(mutex, empty);
consumer the item in nextc;
......
} while(TRUE);
}

管程方案

//定義一個管程
Monitor procducerconsumer {
item buffer[N];//緩沖區大小
int in, out;//訪問下標
condition notfull, notempty;//條件變量
int count;//已生產產品的個數
//生產方法
void put(item x) {
if(count>=N){
notfull.wait; //如果生產個數已經大於緩沖區大小，將生產進程添加到notfull條件的等待隊列中
}
buffer[in] = x; //設置元素
in = (in+1) % N; //下標移動
count++;//已生產產品個數+1
notempty.signal //釋放等待notempty條件的進程
}

//獲取方法
void get(item x) {
if(count<=0){
notempty.wait; // 如果已生產產品數量為0（以下），消費者進程添加到notempty的等待隊列中
}
x = buffer[out];// 讀取元素
out = (out+1) % N; // 下標移動
count--; //已生產產品個數-1
notfull.signal; // 釋放等待notfull條件的進程
}
//初始化數據方法
void init(){
in=0;out=0;count=0;
}
} PC;

void producer(){
item x;
while(TRUE){
produce an item in nextp;
PC.put(x);
}
}
void consumer( {
item x;
while(TRUE) {
PC.get(x);
consume the item in nextc;
......
}
}
void main(){
proceducer();
consumer();
}

哲學家進餐

記錄型信號量機制

//定義五個信號量
//為簡單起見，假定數組起始下標為1
//信號量全部初始化為1
semaphore chopstick[5]={1,1,1,1,1};
do{
//按照我們上面圖中所示，第 i號哲學家，左手邊為i號筷子，右手邊是 (i+1)%5
wait(chopstick[i]);//等待左手邊的，
wait(chopstick[(i+1)%5]);]);//等待右手邊的
// 進餐......
signal(chopstick[i]);//釋放左手邊的
signal(chopstick[(i+1)%5])//釋放右手邊的
// 思考......
} while(TRUE);

AND型信號量

//定義五個信號量
//為簡單起見，假定數組起始下標為1
//信號量全部初始化為1
semaphore chopstick[5]={1,1,1,1,1};

do{
//按照我們上面圖中所示，第 i號哲學家，左手邊為i號筷子，右手邊是 (i+1)%5
Swait(chopstick[i],chopstick[(i+1)%5]))
// 進餐......
Ssignal(chopstick[i],chopstick[(i+1)%5]);
// 思考......
} while(TRUE);

讀者寫者問題

記錄型信號量機制

//兩個信號量，一個用於讀者互斥 readcount ，一個用於讀寫互斥
semaphore rmutex=l,wmutex=1;
int readcount=0;//初始時讀者個數為0
//讀者
void reader() {
do{
wait(rmutex);//讀者先獲取 readcount
if(readcount==0){//如果一個讀者沒有，第一個讀者需要與寫者互斥訪問
wait(wmutex);
}
readcount++;//讀者個數+1
signal(rmutex);//讀者個數+1後，可以釋放readcount的鎖，其他讀者可以進來
//開始慢慢讀書......
wait(rmutex);//讀者結束時，需要獲取readcount的鎖
readcount--;//退出一個讀者
if (readcount==0) {//如果此時一個讀者都沒有了，還需要釋放與讀寫互斥的鎖
signal(wmutex);
}
signal(rmutex);//釋放readcount的鎖
}while(TRUE);
}

void writer(){
do{
wait(wmutex);//寫者必須獲得wmutex
//執行寫任務....
signal(wmutex);//寫任務結束後就可以釋放鎖
}while(TRUE);

}

//主程序
void main() {
reader();
writer();
}

信號量集機制

int N;//最大的讀者個數，也就是相當於圖書館的空位子，初始時空位子為N

semaphore L=N, mx=1;//定義兩個信號量資源L和mx，分別用於控制讀者個數限制和讀寫（寫寫)

void reader() {

do{

Swait(L, 1, 1);//獲取空位子L，每次獲取1個，>=1時可分配

Swait(mx, 1, 0);//獲取與寫的互斥量mx，每次獲取0個，>=1時可分配，如果mx為1，也就是沒有寫者，讀者都可以進來，否則一個都進不來

//進行一些讀操作

Ssignal(L, 1);//釋放一個單位的資源L

}while(TRUE);

}
 

void writer() {

do{

Swait(mx,1,1; L,N,0);//獲得資源mx，每次獲取1個，>=1時分配，獲得資源L，每次獲得0個，>=N時即可分配

//進行一些寫操作

Ssignal(mx, 1);//釋放資源mx

}while(TRUE);

}


void main(){

reader();

writer();

}

總結

進程同步經典示例 多線程上篇（五）