linux多線程-作業系統線程同步互斥__linux

這一目主要我想得是理論和實際結合的辦法去做，先將理論，把這塊在作業系統中的內容先進行陳述。然後用linux下的代碼去真正實現。 Perterson演算法 理論

Perterson演算法是用來是實現對臨界區資源的互斥訪問，它是用軟體的機制實現。也就是說在linux系統編程當中，如果不讓你使用pthread_mutex_t mutex你怎麼解決這個問題。Perterson演算法給出了軟體實現的方法。 虛擬碼

bool flag[] = {false, false}; // flag[i]表示進程i是否想進入臨界區，true表示想進入int turn; // turn = i，表示可進入臨界區的進程是ivoid P0(){    while(true){        flag[0] = true; // 自己想進入        turn = 1;       // 但是，禮讓對方        while( flag[1] && 1==turn ); // 此時符合P1的執行條件，讓進程1執行，進程0此時忙等待        /*         *critical region         * */        flag[0] = false;    }}void P1(){    while(true){        flag[1] = true;        turn = 0;        while( flag[0] && 0==turn );        /*         *critical region         * */        flag[1] = false;    }}

來分析一下上面這段代碼，如果因為turn作為公用資源，並且對它本省不加鎖，所以，必然有一個後訪問它的進程，假設是P1.那就是P0先訪問，P1緊接著就訪問，也就是說其實他們兩都想訪問。但是P0比P1稍微快一點，此時P0進來之後，先表示自己想進臨界區，然後讓對方先進turn=1。P1比P0慢一點，此時P1也想進，那麼flag[1]=true;;turn=0;注意，在turn=0之前，由於P0先執行了，所以P0一直在忙等待，此時turn=0之後，P0進入臨界區，由於turn儲存的是較晚的一次賦值，所以，如果turn=0。表示P1是後進來的，那麼此時P0先進去執行即可。

如果，不存在均要求進入的情況，那就簡單了。 生產者-消費者問題 理論

這一塊，主要是參考了本科時的作業系統課本。具體的內容就不多說了，給出虛擬碼我覺得已經很清晰了。

#define N 128        // 緩衝區大小即緩衝池中緩衝區個數int buffer[N];       // 緩衝池int front = 0;       // 隊列頭int rear = 0;        // 隊列尾下一個semaphore mutex = 1; // 互斥訊號量semaphore full = 0;  // 同步訊號量 - 滿緩衝區個數semaphore empty = N; // 同步訊號量 - 空緩衝區個數void producer(){    P(empty);    produce an item;    P(mutex);    buffer[rear] = item;    rear = (rear+1)%N;    V(mutex)    V(full)}void consumer(){    P(full);    P(mutex);    item = buffer[front];    front = (front+1)%N;    V(mutex);    consume an item;    V(empty);}/*當然，嚴格的代碼中,semaphore是結構體。上面的代碼只是便於理解。 * */typedef list_of_process LP; // 這種類型沒有，暫時先這麼寫typedef semaphore{    int value;    LP L; // 資源的進程阻塞隊列}semaphore_t;void P( semaphore_t& S ){ // atomically    S.value = S.value - 1;    if( S.value < 0 )        block(S.L);}void V( semaphore_t& S ){ // atomically    S.value = S.value + 1;    if(S.value <= 0)        wakeup(S.L);}

補充：這麼搞，在真實寫代碼的時候有問題吧。雖然生產者和消費者訪問的是不同的單元，但是對於隊列的操作。生產者和消費者可能會有問題吧。一定好把問題分析清楚，這到底是不是讀者－寫者問題。不是。。。因為，訪問的不是同一個單元。

新的認識
之前對於上面的問題認識的不夠透徹，其實我最近在linux下面寫的代碼不能算是生產者－消費者。也不是讀者－寫者。它就是兩個寫者，那鎖去控制互斥，訊號量控制同步就可以了。
但是，上面的代碼，我已經分析清楚了。不是讀者－寫者，因為訪問的並不是同一個變數。沒有讀－寫的矛盾。

上面的問題就是經典的生產者－消費者問題。只不過我的問題是，你的mutex是幹嘛的。
現在想清楚了，就是加在整個隊列上面的。
因為我之前的理解不是這樣，我認為如果是單生產者和單消費者，是不需要mutex的，因為生產者和消費者本質沒有訪問同一個變數。所以，他們之間只有同步的語義。互斥的語義是加在生產者與生產者，消費者與消費者之間的。這麼想確實沒有錯，因為不同的生產者要申請單元，不能兩個生產者申請同一個單元。所以，他們之間需要互斥。消費者同理。

所以，我當初認為，單個生產者單個消費者，和多個生產者多個消費者的區別就在於，前者沒有同類對象之間的鎖。但是，現在，這種想法是不對的。其實，基本上也沒問題。

考慮這樣的一個情境：對於一個隊列，有一個生產者，有一個消費者。好了，現在，隊列中只有一個元素。

同時來了生產者和消費者，注意，隊列假設用鏈表實現。此時，隊列中只有一個元素。設當前這個節點的指標為p，對於生產者而言，它要在p的後面追加一個元素，而消費者要釋放p。此時，兩個代碼都執行了，假設消費者稍快於生產者，釋放了p。而此時生產者由於已經過了判斷隊列是否為空白的情形，任然執行p->next = q;那麼，顯然，程式會出錯。
這就是問題，起碼這個是我想到的。對於生產者和消費者而言，隊列上面要加一把鎖。這個鎖可以避免同一類對象申請資源，也可以避免不同對象對於隊列的修改。但是，這樣也會帶來問題，就是生產的時候不能消費，消費的時候不能生產。按理說，他們兩的邏輯是沒關係的。 哲學進餐問題 讀者-寫者問題

問題描述：讀者－寫者是這樣的一個問題。允許多個線程同時讀，但是，但是，只允許一個線程寫。也就是說，如果一個線程在寫，那麼其他線程不能寫也不能讀。但是，如果一個線程在讀，其他線程可以讀，但是不能寫。

問題分析：考慮讀者－寫者之間用互斥實現，這樣可以避免讀者－寫者之間的互斥。此時，讀的時候不能寫，寫的時候不能讀。但是，這麼做會導致，讀的時候也不能讀了。所以，這是問題。在讀者之間還需要實現一定程度的共用。

此時，可以考慮給讀者一個計數器，當這個計數器不為０的時候，其他讀者只需修改計數器的值，然後去讀就好了。不用等待讀者和寫者之間的鎖。然後讀取操作結束，修改計數器的值即可。在計數器值為０的時候，需要申請和釋放。顯然，不同讀者之間對於這個計數器是共用的，所以也需要互斥訪問。

semaphore_t rmutex = 1;semaphore_t wmutex = 1;void reader(){    P(rmutex);    if(readcount == 0) P(wmutex);    readcount++;    V(rmutex);    /* read operation */    P(rmutex);    readcount--;    if(readcount == 0) V(wmutex);    V(rmutex);}void writer(){    P(wmutex);    /* write operation */    V(wmutex);}