前兩天寫了個簡單的執行緒池，結果在處理執行緒的同步互斥上花了不少時間，覺得有必要把以前學習的知識再過一遍，這次主要複習的是幾個非常經典的同步互斥問題。

一、生產者消費者問題 問題描述： 只有緩衝區沒滿時，生產者才能把訊息放入到緩衝區，否則必須等待；只有緩衝區不空時，消費者才能從中取出訊息，否則必須等待。由於緩衝區是臨界資源，它只允許一個生產者放入訊息，或者一個消費者從中取出訊息。 問題分析： 1、關係分析：生產者和消費者對緩衝區互斥訪問是互斥關係，同時生產者和消費者又是一個相互協作的關係，只有生產者生產之後，消費者才能消費，它們也是同步關係。 2、整理思路：因為只有生產者和消費者兩個執行緒，且這兩個執行緒存在著互斥關係和同步關係。那麼需要解決的是互斥和同步的PV操作的位置。 3、訊號量設定：互斥鎖mutex用於控制互斥訪問緩衝池；訊號量full用於記錄當前緩衝池中“滿”緩衝區數，初值為 0；訊號量empty用於記錄當前緩衝池中“空”緩衝區數，初值為n。

#define N 10
sem_t empty;//空閒緩衝區訊號量，初始化為N
sem_t full;//滿緩衝區訊號量，初始化為0
pthread_mutex_t mutex;//對緩衝區產品互斥訪問
int product_num = 0;//緩衝區產品數目

void *producter_f(void *arg)
{
        while (1)
        {
                usleep(1000000);
                printf("produce an item\n");//生產資料
                sem_wait(&empty);//獲取空緩衝區單元
                pthread_mutex_lock(&mutex);//進入臨界區
                product_num++;//將資料放入緩衝區
                printf("producter: the num of product is %d\n", product_num);
                pthread_mutex_unlock(&mutex);//離開臨界區
                sem_post(&full);//滿緩衝區加1
        }
}

void *consumer_f(void *arg)
{
        while (1)
        {
                sem_wait(&full);//獲取空緩衝區單元
                pthread_mutex_lock(&mutex);//進入臨界區
                product_num--;
                printf("consumer: the num of product is %d\n", product_num);
                pthread_mutex_unlock(&mutex);//離開臨界區
                sem_post(&empty);//空緩衝區加1
                usleep(5000000);
                printf("consume an item\n");//消費資料
        }
}
 

執行結果：
該類問題要注意對緩衝區大小為n的處理，當緩衝區中有空時便可對empty變數執行P 操作，一旦取走一個產品便要執行V操作以釋放空閒區。對empty和full變數的P操作必須放在對mutex的P操作之前。如果生產者執行緒先執行P(mutex)，然後執行P(empty)，消費者執行P(mutex),然後執行P(fall),這樣可不可以？答案是否定的。設想生產者執行緒已經將緩衝區放滿，消費者執行緒並沒有取產品，即empty = 0，當下次仍然是生產者執行緒執行時，它先執行P(mutex)封鎖訊號量，再執行P(empty)時將被阻塞，希望消費者取出產品後將其喚醒。輪到消費者執行緒執行時，它先執行P(mutex)，然而由於生產者執行緒已經封鎖mutex訊號量，消費者執行緒也會被阻塞，這樣一來生產者、消費者執行緒都將阻塞，都指望對方喚醒自己，陷入了無休止的等待。同理，如果消費者執行緒已經將緩衝區取空，即 full = 0,下次如果還是消費者先執行，也會出現類似的死鎖。不過生產者釋放訊號量時，mutex、full先釋放哪一個無所謂，消費者先釋放mutex還是empty都可以。 二、讀者-寫者問題

問題描述： 有讀者和寫者兩組併發執行緒，共享一個檔案，當兩個或以上的讀執行緒同時訪問共享資料時不會產生副作用，但若某個寫執行緒和其他執行緒（讀執行緒或寫執行緒）同時訪問共享資料時則可能導致資料不一致的錯誤。因此要求：①允許多個讀者可以同時對檔案執行讀操作；②只允許一個寫者往檔案中寫資訊；③任一寫者在完成寫操作之前不允許其他讀者或寫者工作；④寫者執行寫操作前，應讓已有的讀者和寫者全部退出。 問題分析： 1) 關係分析。由題目分析讀者和寫者是互斥的，寫者和寫者也是互斥的，而讀者和讀者不存在互斥問題。 2) 整理思路。兩個執行緒，即讀者和寫者。寫者是比較簡單的，它和任何執行緒互斥，用互斥訊號量的P操作、V操作即可解決。讀者的問題比較複雜，它必須實現與寫者互斥的同時還要實現與其他讀者的同步，因此，僅僅簡單的一對P操作、V操作是無法解決的。那麼，在這裡用到了一個計數器，用它來判斷當前是否有讀者讀檔案。當有讀者的時候寫者是無法寫檔案的，此時讀者會一直佔用檔案，當沒有讀者的時候寫者才可以寫檔案。同時這裡不同讀者對計數器的訪問也應該是互斥的。 3) 訊號量設定。首先設定訊號量count為計數器，用來記錄當前讀者數量，初值為0; 設定mutex為互斥鎖，用於保護更新count變數時的互斥；設定互斥訊號量rw用於保證讀者和寫者的互斥訪問。

sem_t rw;//保護讀者和寫者互斥地訪問檔案，初始化為1
pthread_mutex_t mutex;//保護更新reader_num時的互斥
int reader_num = 0;//用於記錄讀者數量

void *writer_f(void *arg)
{
        sem_wait(&rw);//互斥訪問共享檔案
        usleep(2000000);
        printf("writing ...\n");
        sem_post(&rw); //釋放共享檔案
}

void *reader_f(void *arg)
{
        pthread_mutex_lock(&mutex);//互斥訪問reader_num變數

        if (reader_num == 0)
        {
            sem_wait(&rw);//阻止寫執行緒寫
        }
        reader_num++;//讀者計數器加1
        printf("reader num add the num is %d \n", reader_num);
        pthread_mutex_unlock(&mutex);//釋放互斥變數


        usleep(2000000);
        printf("reading ...\n");

        pthread_mutex_lock(&mutex);//互斥訪問reader_num變數

        reader_num--;//讀者計數器減1
        printf("reader num dec the num is %d \n", reader_num);

        if (reader_num == 0)
        {
                sem_post(&rw);//允許寫執行緒寫
        }

        pthread_mutex_unlock(&mutex);//釋放互斥變數
}
 

執行結果：
在上面的演算法中，讀執行緒是優先的，也就是說，當存在讀執行緒時，寫操作將被延遲，並且只要有一個讀執行緒活躍，隨後而來的讀執行緒都將被允許訪問檔案。這樣的方式下，會導致寫執行緒可能長時間等待，且存在寫執行緒“餓死”的情況。 如果希望寫執行緒優先，即當有讀執行緒正在讀共享檔案時，有寫執行緒請求訪問，這時應禁止後續讀執行緒的請求，等待到已在共享檔案的讀執行緒執行完畢則立即讓寫執行緒執行，只有在無寫執行緒執行的情況下才允許讀執行緒再次執行。為此，增加一個訊號量並且在上面的程式中 writer_f()和reader_f()函式中各增加一對PV操作，就可以得到寫執行緒優先的解決程式。

sem_t rw;//保護讀者和寫者互斥地訪問檔案，初始化為1
sem_t w;//用於實現寫優先，初始化為1
pthread_mutex_t mutex;//保護更新reader_num時的互斥
int reader_num = 0;//用於記錄讀者數量

void *writer_f(void *arg)
{
        sem_wait(&w);
        sem_wait(&rw);//互斥訪問共享檔案
        usleep(2000000);
        printf("writing ...\n");
        sem_post(&rw); //釋放共享檔案
        sem_post(&w);
}

void *reader_f(void *arg)
{
        sem_wait(&w);
        pthread_mutex_lock(&mutex);//互斥訪問reader_num變數

        if (reader_num == 0)
        {
            sem_wait(&rw);//阻止寫執行緒寫
        }
        reader_num++;//讀者計數器加1
        printf("reader num add the num is %d \n", reader_num);
        pthread_mutex_unlock(&mutex);//釋放互斥變數
        sem_post(&w);

        usleep(2000000);
        printf("reading ...\n");

        pthread_mutex_lock(&mutex);//互斥訪問reader_num變數

        reader_num--;//讀者計數器減1
        printf("reader num dec the num is %d \n", reader_num);

        if (reader_num == 0)
        {
                sem_post(&rw);//允許寫執行緒寫
        }

        pthread_mutex_unlock(&mutex);//釋放互斥變數
}

三、哲學家進餐問題 問題描述： 一張圓桌上坐著5名哲學家，每兩個哲學家之間的桌上擺一根筷子，桌子的中間是一碗米飯，如圖2-10所示。哲學家們傾注畢生精力用於思考和進餐，哲學家在思考時，並不影響他人。只有當哲學家飢餓的時候，才試圖拿起左、 右兩根筷子（一根一根地拿起）。如果筷子已在他人手上，則需等待。飢餓的哲學家只有同時拿到了兩根筷子才可以開始進餐，當進餐完畢後，放下筷子繼續思考。 問題分析： 1) 關係分析。5名哲學家與左右鄰居對其中間筷子的訪問是互斥關係。 2) 整理思路。顯然這裡有五個執行緒。本題的關鍵是如何讓一個哲學家拿到左右兩個筷子而不造成死鎖或者飢餓現象。那麼解決方法有兩個，一個是讓他們同時拿兩個筷子；二是對每個哲學家的動作制定規則，避免飢餓或者死鎖現象的發生。 3) 訊號量設定。定義互斥訊號量陣列chopstick[5] = {l, 1, 1, 1, 1}用於對5個筷子的互斥訪問。 對哲學家按順序從0～4編號，哲學家i左邊的筷子的編號為i，哲學家右邊的筷子的編號為(i+l)%5。 該演算法存在以下問題：當五個哲學家都想要進餐，分別拿起他們左邊筷子的時候（都恰好執行完wait(chopstick[i]);)筷子已經被拿光了，等到他們再想拿右邊的筷子的時候（執行 wait(chopstick[(i+l)%5]);)就全被阻塞了，這就出現了死鎖。
為了防止死鎖的發生，可以對哲學家執行緒施加一些限制條件，比如至多允許四個哲學家同時進餐;僅當一個哲學家左右兩邊的筷子都可用時才允許他抓起筷子;對哲學家順序編號，要求奇數號哲學家先抓左邊的筷子，然後再轉他右邊的筷子，而偶數號哲學家剛好相反。正解制定規則如下：假設釆用第二種方法，當一個哲學家左右兩邊的筷子都可用時，才允許他抓起筷子。

sem_t chopstick[N];//定義訊號量陣列，初始化為1
pthread_mutex_t mutex;//保護取筷子時的互斥
int reader_num = 0;//用於記錄讀者數量

void *philosopher_i(void *arg)
{
        int index = *(int *)arg;

        pthread_mutex_lock(&mutex);//在取筷子前獲得互斥量
        sem_wait(&chopstick[index]);//取左邊筷子
        sem_wait(&chopstick[(index+1) % 5]);//取右邊筷子
        printf("get two chopstick the index is %d\n", index);
        pthread_mutex_unlock(&mutex);//釋放取筷子的互斥量
        usleep(2000000);
        printf("eating... the index is %d\n", index);//進餐

        sem_post(&chopstick[index]);//放回左邊筷子
        sem_post(&chopstick[(index+1) % 5]);//放回右邊筷子
        usleep(2000000);        
        printf("thinking... the index is %d\n", index);//思考
}

執行結果：
四、吸菸者問題 問題描述： 假設一個系統有三個抽菸者執行緒和一個供應者執行緒。每個抽菸者不停地捲菸 並抽掉它，但是要捲起並抽掉一支菸，抽菸者需要有三種材料：菸草、紙和膠水。三個抽菸 者中，第一個擁有菸草、第二個擁有紙，第三個擁有膠水。供應者執行緒無限地提供三種材料， 供應者每次將兩種材料放到桌子上，擁有剩下那種材料的抽菸者卷一根菸並抽掉它，並給供 應者一個訊號告訴完成了，供應者就會放另外兩種材料在桌上，這種過程一直重複（讓三個 抽菸者輪流地抽菸)。 問題分析： 1) 關係分析。供應者與三個抽菸者分別是同步關係。由於供應者無法同時滿足兩個或 以上的抽菸者，三個抽菸者對抽菸這個動作互斥（或由三個抽菸者輪流抽菸得知 2) 整理思路。顯然這裡有四個執行緒。供應者作為生產者向三個抽菸者提供材料。 3) 訊號量設定。訊號量offer1、offer2、offer3分別表示菸草和紙組合的資源、菸草和 膠水組合的資源、紙和膠水組合的資源。訊號量finish用於互斥進行抽菸動作。

sem_t offer1;//定義訊號量對應菸草和紙組合的資源，初始化為1
sem_t offer2;//定義訊號量對應菸草和膠水組合的資源，初始化為1
sem_t offer3;//定義訊號量對應紙和膠水組合的資源，初始化為1
sem_t finish;//定義訊號量表示吸菸者是否完成，初始化為1

void *provider_f(void *arg)
{
        while (1)
        {
                int rand_num = rand() % 3;
                if (rand_num == 0)
                {
                        sem_post(&offer1);//提供菸草和紙
                }
                else if (rand_num == 1)
                {
                        sem_post(&offer2);//提供菸草和膠水
                }
                else
                {
                        sem_post(&offer3);//提供紙和膠水
                }

                usleep(1000000);
                printf("put two material on table\n");

                sem_wait(&finish);
        }
}

void *smoker1_f(void *arg)
{
        while (1)
        {
                sem_wait(&offer1);
                usleep(1000000);
                printf("remove the paper and glue\n");//拿走紙和膠水
                sem_post(&finish);
        }   
}

void *smoker2_f(void *arg)
{
        while (1)
        {
                sem_wait(&offer2);
                usleep(1000000);
                printf("remove the tobacco and glue\n");//拿走菸草和膠水
                sem_post(&finish);
        }   
}

void *smoker3_f(void *arg)
{
        while (1)
        {
                sem_wait(&offer3);
                usleep(1000000);
                printf("remove the paper and tobacco\n");//拿走紙和菸草
                sem_post(&finish);
        }   
}

執行結果：