前篇在此：

正文

9-1 同步互斥、臨界區、死鎖、互斥概念等等

多個程序會互動，對共享資源的訪問。處理不當就會飢餓，死鎖。

獨立的執行緒：不和其他執行緒共享資源或狀態，不互動，所以具有確定性（輸入狀態決定結果），可重現（能重現起始條件），I/O，排程順序不重要
合作的執行緒：在多個執行緒中共享狀態，不確定性，不可重現
不確定性和不可重現意味著BUG可能是間歇性發生的

為什麼要合作？
共享資源（嵌入式系統）；
加速，效率高（I/O操作和計算可以重疊，拆分小任務，流水，並行，多處理器）；
模組化：大程式分解成小程式，使系統易於擴充套件

存在的問題——>舉例：

希望是
無論多個執行緒的指令序列怎麼交替，程式都必須正常工作，除錯難度很高；
不確定性要求並行程式的正確性，一定更要預先思考。
Race condition 競態條件
結果依賴於併發執行的時間點 順序/時間

怎麼避免？如何不讓指令被打斷？
atomic operation原子操作
指一次不存在任何中斷或者失敗的執行，要麼成功done要麼沒執行
實際操作往往不是原子的，甚至單個機器指令都不一定是原子的。
對記憶體的load store是原子的，但++ 、–都不是

臨界區critical section：
程序中訪問共享資源的程式碼區域，且當另一個程序處於相應程式碼區域時便不會執行。

互斥mutual exclusion：
任一時刻只能有一個程序進入臨界區訪問。當一個程序處於臨界區並訪問共享資源時，沒有其他程序會處於臨界區，並訪問任何相同的共享資源。

死鎖Dead lock
多個程序相互等待完成特定任務，而最終沒法繼續自身任務

飢餓starvation：
一個可執行的程序長期等待執行，被排程器持續忽略。

可以留便籤，但還是做不到，因為上下文切換不知道何時會發生。
便籤上打不同的標籤→不同標籤的Note+不同程式碼的執行緒/程序
一個while 一個if
busy-waiting 當A等待DO nothing時浪費了CPU的時間，忙等待。
而且有不對稱性

以買麵包bread為例：

假設有一些鎖
breadlock.acquire(): -----enter the critical section 在鎖被釋放前一直等待，然後獲得鎖
if(no bread)
{buy bread;}
lock.release():-----exit the critical section 解鎖並喚醒任何等待中的鎖
release and acquire都要是原子操作，如果兩個程序同時發現了一個被釋放了的鎖，那麼只有一個能獲得

9-2 臨界區和三種滿足效能的方法

臨界區的特點：

• 互斥
• progress前進，如果一個執行緒想要進入臨界區，不會一直死等，總能成功
• 優先等待，如果一個執行緒i處於入口區，那麼i的請求被接受之前，其他執行緒進入臨界區的時間是有限制的。否則，飢餓。是對progress的補充
• 無忙等待：儘量不要忙等，如果程序一直等待進入臨界區，那麼在它可以進入之前會被掛起。（可以不滿足）

三種方法：禁用硬體中斷，基於軟體，更高階的抽象

（1）禁用硬體中斷：
沒有中斷，就沒有上下文切換，沒有併發。減少不確定性。進入臨界區禁用中斷，退出時再開啟。
問題：
一旦禁用中斷，執行緒無法停止
整個系統都會停下來，I/O啥的都沒用了，其他執行緒可能會飢餓 影響效率
臨界區要是太長咋整？無法限制響應中斷所需的時間，可能有硬體影響。一般都用於短的臨界區時間。
如果兩個CPU並行的話，一個CPU只能遮蔽自身，另一個仍可能產生中斷。

（2）基於軟體的方式

共享變數初始化

int turn=0;         //初始是Ti進入臨界區
對Thread Ti，有：
do{
    while(turn!=i);     //  busy waiting
    critical section
    turn=j;                 //after exit turn=j
    reminder section
}while (1);

Ti在退出臨界區後做其他的事情去了，Tj想繼續執行，但必須等待Ti處理臨界區

必須是一種交替迴圈。
改進，用陣列flag

flag[i]==1 程序i想進入臨界區執行
int flag[2];
flag[0]=flag[1]=0;
do{
while(flag[j]==1) ;  //初始flag都是0，沒有滿足互斥
flag[i]==1;   //先請求
critical section
flag[i]=0;
remainder section
}while (1)

如果先flag[i]=1再while迴圈，可能死鎖

滿足程序Pi and Pj之間互斥的正解：

use two shared data items
int  turn; // who ‘s turn to enter the critical section
bollean flag[];  //whether the process is ready to enter
PETERSON演算法
do{
flag[i] = TURE;
turn=j;
while(flag[j]&&turn==j ) ;
 CRITICAL SECTION
flag[i]=FLASE;
    REMAINDER SECTION
} while(TURE);

對N個程序，Eisenberg and Mcguire’s algorirhm

程序i之前的先進入了i再進入，i之後的等i先進入

Bakery演算法
N個程序的臨界區 排號，只有一個視窗
進入前，程序接受一個數字，數字最小的進入臨界區。如果Pi和Pj
得到相同的數字，比較i,j的大小，小的進入。編號方案總是按照列舉的增加順序生成數字。

問題：
複雜；需要共享資料項
耗資源；需要忙等待，浪費CPU時間
沒有硬體保證的情況下無真正的軟體解決方法；load store必須要是原子操作

（3） 基於硬體原子操作的高層抽象實現
硬體提供了一些原語，用原子操作直接實現進退臨界區
鎖是一個抽象的資料結構，獲得鎖就是進入臨界區的實現過程
lock_next_pid->acquire();
new_pid=next_pid++ ;
lock_next_pid->release();

大多數現代體系結構都提供特殊的原子操作指令
（1） test-and-set 測試和置位
從記憶體中讀值，判斷是否為1並返回，同時設定記憶體值為1
（2） exchange 交換 輸入兩個記憶體單元，交換其值並返回
這兩條如果有一條可以是原子指令，就可以完成

lock::release(){value=0;}
可以支援N個程序的操作且是一樣的，都很簡潔
改進：讓它不忙等
當它等待其他事件時，可以睡眠/阻塞

class lock{ int value = 0; waitqueue q;}
lock::acquire(){
while (test-and-set(value)){
add this TCB to wait queen q;
schedule();}
}
lock::release(){
value=0;
remove one thread t from q;
wakeup(t);
}

如果臨界區短，開銷小於上下文切換的開銷，直接忙等，否則要引入WAITING和wakeup

int lock=0;
to process Ti that want to enter the critical section
int key;
do{
key=1;
while(key==1)exchange(lock,key);   //when key!=1 swap out of
critical section  //at that time key=0 lock=1
    lock=0;
remainder section
}

實現簡單，易擴充套件到多臨界區，開銷小，適用於單處理器或共享主存的多處理器中任意數量的程序 廣泛使用
缺點： 還是有忙等，浪費時間；
搶LOCK隨機可能某個一直搶不到，當程序離開臨界區，且多個程序在等待時可能導致飢餓；
也許死鎖，一個低優先順序的程序擁有臨界區，一個高優先順序的 程序也需求，那麼高優先順序程序忙等，佔用cpu,低優先順序的不能釋放Lock，要通過優先順序反轉來解決。

總結：

用鎖來解決互斥問題，鎖是高層程式設計抽象，需要一定硬體支援
常用三種：禁用中斷（僅可單處理器），軟體方法（複雜），原子操作指令（單處理器或多處理器都可以）
可選的實現內容：有忙等待，無忙等待（程序睡眠）