程式同步

1.程式同步的基本概念

程式同步的主要任務是對多個相關程式在執行次序上進行協調，
使併發執行的諸程式之間能夠按照一定的規則（或時序）共享系
統資源，並能很好的相互合作，從而使程式的執行具有可再現性。123

兩種制約關係

在多道程式環境下，對於處於一個系統中的多個程式，由於他們共享資源，或為完成某一任務而相互合作，他們之間可能存在著以下兩種形式的制約關係：
1）間接相互制約：多個程式在併發執行時，由於共享系統資源，如CPU，I/O裝置等，致使這些併發執行的程式之間形成相互制約的關係。為了保證這些程式的能有序執行，對於系統中的這類資源，必須由系統統一分配，即使用者在使用之前，應先提出申請，而不允許使用者程式直接使用。這種制約關係源於對該類資源的共享。
2）直接相互制約關係：為了完成某任務而建立的兩個或者多個程式。這些程式將為完成同一項任務而相互合作。例如生產者——消費者問題就存在著相互制約關係程式間的直接制約關係源於他們之間的相互合作。

在多道程式環境下，由於存在著上述兩類相互制約關係，程式執行過程中是否能獲得處理機執行以及以怎樣速度執行，並不是程式自身能控制的，此即程式的非同步性。

臨界資源和臨界區

在計算機中有許多資源一次只能允許一個程式使用，如果多個程式同時使用則可能造成系統的混亂，這些資源被稱作臨界資源（比如印表機）。多個程式同時使用臨界資源會使其結果具有不可再現性。

在每個程式中，訪問臨界資源的那段程式碼稱作臨界區。為了使程式能有效共享臨界資源，並使程式的執行具有可再現性，系統必須保證程式互斥的使用臨界資源，即保證他們互斥的進入臨界區。因此，必須在臨界區前面加一段程式碼，用來檢查對應的臨界資源是否正被其他程式訪問，這段程式碼稱為進入區；相應的在臨界區後邊也要加一段程式碼稱為退出區，用於將臨界區從正在被訪問的標誌恢復為未被訪問的標誌。

同步機制應該遵循的規則

用來實現互斥的共享機制必須遵守以下四個規則：
1）空閒讓進：臨界區空閒時，應允許一個請求進入臨界區的程式立即進入臨界區，以便有效的利用資源。
2）忙則等待：當臨界資源正在訪問時，其他要求進入臨界區的程式必須等待，以保證對臨界資源的互斥訪問。
3）有限等待：任何要求訪問臨界資源的程式應能在有限時間內進入臨界區。
4）讓權等待：不能進入臨界區的程式應立即釋放CPU資源，以免“忙等”。

2.訊號量機制

介紹：訊號量機制是荷蘭學者Dijkstra在1965年提出的一種同步機制。
本篇文章注重介紹整型訊號量和記錄型訊號量。12

整型訊號量

最初由Dijkstra把整型訊號量定義為一個用於表示資源數目的整型量S，除了初始化外，它僅能透過兩個標準的原子操作wait（P）和signal（V）來訪問。演算法如下：

wait(S){
    while(S <= 0); 
    	*表示資源正被佔用，迴圈等待（不遵循“讓權等待”的準則
    						而是使之處於忙等狀態）*
    S--;
}
signal(S){
    S++;
}12345678910

記錄型訊號量

記錄型訊號量除了需要一個用於代表資源數目的整型變數value外，還增加了一個程式連結串列指標list，用於連結所有等待該資源的程式。其演算法如下：

typedef struct{
    int value;
    struct process_control_block *list;
} semaphore;
wait和signal操作可描述為：
wait(semaphore *S){
    S->value--;
    			*wait申請資源,資源數減1*
    if(S->value < 0)    
   				*S->value自減之後<0則表示系統中已無資源分配*
        block(S->list);
        		*block自我阻塞，放棄CPU，並插入到S->list中*
} 
signal(semaphore *S){
    S->value++;
    			*釋放資源，value加1*
    if(S->value <= 0)
    			*value加1之後value仍然<=0,表示仍然有等待該資源
    			的程式被阻塞，所以用wakeup將等待連結串列中的第一
    			個程式喚醒*
        wakeup(S->value);
}123456789101112131415161718192021222324

3.訊號量應用

利用訊號量實現前趨關係

前趨關係在上一篇文章已將這裡就不多說，直接上圖寫關係在這裡插入圖片描述
程式碼框架如下：

P1(){signal(a);}
p2(){wait(a); signal(b); signal(c);}
P3(){wait(b); wait(d); signal(e);}
P4(){wait(c); signal(d); signal(f);}
P5(){wait(f); wait(e);}12345

利用訊號量實現互斥

為了使多個程式能互斥地訪問某個臨界資源，只需為該資源設定一互斥訊號量mutex ,並將其訊號量設定為1，然後將訪問該臨界區的資源放wait(mutex)和signal(mutex)之間。下面演算法描述瞭如何利用訊號量實現程式P1和P2的互斥：

semaphore mutex = 1;
p1(){
    while(1){
        wait(mutex);
        臨界區
        signal(mutex)
        剩餘區
    }
    
}
p2(){
    while(1){
        wait(mutex);
        臨界區
        signal(mutex)
        剩餘區
    }
}123456789101112131415161718

在利用訊號量機制實現程式互斥時需要注意，wait(mutex)和signal(mutex)必須成對出現，（成對出現不一定在一個程式中成對出現）缺少wait(mutex)將會導致系統混亂，不能保證對臨界資源的互斥訪問；而缺少signal(mutex)j將會使臨界資源永遠不被釋放，從而使因等待該資源的程式不能被喚醒。

4.經典程式的同步問題

生產者—消費者問題(個人理解)

（一個緩衝區的就不說了）如果一個生產者一個消費者n個緩衝區：
設定三個訊號量：
互斥訊號量 mutex，用於實現對緩衝池的互斥訪問，初始值為1；
資源訊號量 empty，用來表示空閒緩衝區的數量，初始值n；
資源訊號量 full，用來表示滿緩衝區的數量，初始值為0；
empty和full用來同步生產者和消費者程式。
具體演算法描述如下：

int in = 0，out = 0;
item buffer[n]
semaphore mutex = 1, empty = n, full = 0;
//生產者
void proceducer(){
    do{
        produce an item nextp;
            ...
        wait(empty);   
         //判斷是否有空閒緩衝池，並申請資源，如果有,則empty（空緩衝區）減一
        wait(mutex)         
         //申請緩衝區資源，並進入緩衝區（準備進行操作）
        buffer[in] = nextp;
        //將產品放入緩衝區
        in = (in + 1) % n;
        signal(mutex);
        //釋放緩衝區資源
        signal(full);
        //滿緩衝區數量加1，釋放資源
    }while(TRUE)；
}
//消費者
void consumer(){
    do{
        wait(full);        
         //判斷是否有滿緩衝區，並申請資源，如果有，則full空緩衝區）減一
        wait(mutex);         
         //申請緩衝區資源，並進入緩衝區（準備進行操作）
        
        nextc = buffer[out];
        //拿出產品
        out = (out + 1) % n;
        signal(mutex) 
        //釋放緩衝區資源
        signal(empty);
        //空緩衝區數量加1，釋放資源
        consume the item in nextc;
            ...
    }while(TRUE)；
}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

注：n個緩衝池用迴圈佇列
當（in + 1）% n = out,表示進來一圈了，也就是緩衝池滿了；
當in = out表示緩衝池空；

讀者—寫者問題(個人理解)

題述：一個資料物件，如筆記或者記錄，能被多個程式共享，可把那些只要求讀資料物件的程式稱為"讀者"，其他程式則稱為寫者。顯然讀者可同時讀一個共享物件，但不允許讀者和寫著同時訪問共享物件，也不允許多個寫著同時訪問共享物件。
如考慮讀者優先，即除非有讀者在讀，或者讀者就不用等待，該問題演算法可描述為：
互斥訊號量mutex：實現Reader和Writer程式間在讀或者寫時的互斥。
互斥訊號量rmutex：實現對readcount互斥訪問。
整型變數readcount：記錄讀者數量。

semaphore rmutex = 1, mutex = 1;
int readcount = 0;
//讀者
void reader(){
    do{
        //進讀者
        wait(rmutex); 
        //判斷readcount資源是否被佔用，若無，則申請資源
        if(readcount == 0) wait(mutex); 
        //如果沒有讀者，則先申請讀寫緩衝區的資源
        readcount ++;
        //讀者數量加1
        signal(rmutex)
        //釋放對readcount資源的佔用
        ...
        perform read operation;
        ...
        //出讀者
        wait(rmutex);
        //判斷readcount資源是否被佔用，若無，則申請資源
        readcount --;
        //讀者數量減1
        if(readcount == 0) signal(mutex);
        //如果讀者出完，則把對讀寫緩衝區的資源釋放    
        signal(rmutex);
        //釋放對readcount資源的佔用
    }while(TRUE);
}
//寫者
void writer(){
    do{
        wait(mutex);
        //寫者只能有一個，不需要在申請對readcount的佔用
        //所以直接申請讀寫緩衝區資源
        perform write operation;
        signal(mutex);
        //釋放對讀寫緩衝區的佔用
    }while(TRUE);
}1234567891011121314151617181920212223242526272829303132333435363738394041424344

生產者—消費者問題變形(個人理解)

問題描述：桌子上有能盛的下5個水果的空盤子，爸爸不停的向盤子中放蘋果或者橘子，兒子不停的從盤子中取走橘子，女兒不停從盤中取出蘋果，規定三人不能同時從盤子中取放水果。試用訊號量實現爸爸，兒子和女兒這三個迴圈程式之間的同步。
本題是生產者—消費者問題的變形，為一個生產者，多個緩衝區，多個消費者。
需要設定兩個不同的full變數orange和apple初始值為0。
三人不能同時取放水果，設定互斥訊號量mutex以實現三人對臨界資源的互斥訪問。
還需設定一個empty記錄盤子中的空位置（五個位置）

該問題演算法可描述為：

semaphore empty = 5, orange = 0, apple = 0, mutex = 1;
Dad(){
    do{
        wait(empty);
        //判斷是否還有空位置，若有，申請相應資源
        wait(mutex);
        //判斷是否臨界資源被其他（兒子，女兒）程式佔用
        //若沒有，這申請資源，進入緩衝區，被佔用則等待
        放水果操作
        signal(mutex);
        //釋放對臨界資源的佔用
        if(orange) signal(orange)
        else signal(apple)
        //如果放入的是橘子，則橘子數量加1，釋放orange
        //否則對apple進行操作
    }while(TRUE)
}
Daughter(){
    do{
        wait(apple)
        //判斷盤子裡是否有蘋果，如果有，則申請相應資源
        wait(mutex)
        //申請進入緩衝區，mutex減1,資源被Daughter佔用，準備對蘋果進行操作
        拿走蘋果
        signal(mutex)
        //拿走蘋果之後，把佔用的臨界資源釋放
        signal(empty)
        //蘋果被拿走，空位置（緩衝區）加1
    }while(TRUE)
}
Son(){
    do{
        wait(orange)
        //判斷盤子裡是否有橘子，如果有，則申請相應資源，orange減1
        wait(mutex)
        //申請進入緩衝區，mutex減1,資源被Son佔用，準備對橘子進行操作
        拿走蘋果
        signal(mutex)
        //拿走橘子之後，把佔用的臨界資源釋放
        signal(empty)
        //橘子被拿走，空位置（空緩衝區）加1
    }while（TRUE）
}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

注：以上僅為個人理解，如有錯誤，還望提出，佔佔積極改正！

計算機作業系統（湯小丹第四版）程式同步