目錄：
1
什麼是程序？
标準定義：程序是一個具有一定獨立功能的程式在一個資料集合上依次動态執行的過程。程序是一個正在執行程式的執行個體，包括程式計數器、寄存器和程式變量的目前值。
簡單來說程序就是一個程式的執行流程，内部儲存程式運作所需的資源。
在作業系統中可以有多個程序在運作，可對于CPU來說，同一時刻，一個CPU隻能運作一個程序，但在某一時間段内，CPU将這一時間段拆分成更短的時間片，CPU不停地在各個程序間遊走，這就給人一種并行的錯覺，像CPU可以同時運作多個程序一樣，這就是僞并行。
2
程序和程式有什麼聯系？
一個程序是某種類型的一個活動，它有程式、輸入、輸出以及狀态。單個處理器可以被若幹程序共享，它使用某種排程算法決定何時停止一個程序的工作，并轉而為另一個程序提供服務。
程式是産生程序的基礎
程式的每次運作産生不同的程序
程序是程式功能的展現
通過多次執行，一個程式可對應多個程序；通過調用關系，一個程序可包括多個程式
3
程序和程式有什麼差別？
程序是動态的，程式是靜态的：程式是有序代碼的集合，程序是程式的執行。
程序是暫時的，程式是永久的：程序是一個狀态變化的過程，程式可長久儲存。
程序和程式的組成不同：程序的組成包括程式、資料和程序控制塊（程序狀态資訊）。
4
程序有什麼特點？
動态性：可動态地建立和結束程序
并發性：可以被獨立的排程并占用處理機并發運作
獨立性：不同程序的工作不互相影響
制約性：因通路共享資源或程序間同步而産生制約
5
程序如何建立？
有什麼事件會觸發程序的建立呢？
系統初始化：當啟動作業系統時，通常會建立很多程序，有些是同使用者互動并替他們完成工作的前台程序，其它的都是背景程序，背景程序和特定使用者沒有關系，但也提供某些專門的功能，例如接收郵件等，這種功能的程序也稱為守護程序。計劃任務是個典型的守護程序，它每分鐘運作一次來檢查是否有工作需要它完成。如果有工作要做，它就會完成此工作，然後進入休眠狀态，直到下一次檢查時刻的到來。
正在運作的程式執行了建立程序的系統調用：在一個程序中又建立了一個新的程序，這種情況很常見。
使用者請求建立一個新程序：這種情況相信每個人都見過，用電腦時輕按兩下某個應用圖示，就會有至少一個程序被建立。
一個批處理作業的初始化：這種情形不常見，僅在大型機的批處理系統中應用，使用者在這種系統中送出批處理作業，在作業系統認為有資源可運作另一個作業時，它建立一個新的程序，并運作其輸入隊列中的下一個作業。
歸根到底：在UNIX系統中，隻有fork系統調用才可以建立新程序，使用方式如下：
#include <stdio.h>
#include <unistd.h>
int main() {
pid_t id = fork();
if (id < 0) {
perror("fork\n");
} else if (id == 0) { // 子程序
printf("子程序\n");
} else { // 父程序
printf("父程序\n");
}
return 0;
} 複制
程序建立之後，父子程序都有各自不同的位址空間，其中一個程序在其位址空間的修改對另一個程序不可見。子程序的初始化空間是父程序的一個副本，這裡涉及兩個不同位址空間，不可寫的記憶體區是共享的，某些UNIX的實作使程式正文在兩者間共享，因為它是不可修改的。
還有一種寫時複制共享技術，子程序共享父程序的所有記憶體，一旦兩者之一想要修改部分記憶體，則這塊記憶體被複制確定修改發生在目前程序的私有記憶體區域。
6
程序為何終止？
有什麼事件會觸發程序的終止呢？
正常退出（自願）：程序完成了工作正常終止，UNIX中退出程序的系統調用是exit。
出錯退出（自願）：程序發現了錯誤而退出。可以看如下代碼：
#include <stdio.h>
#include <stdlib.h>
void Func() {
if (error) { // 有錯誤就退出程式
exit(1);
}
}
int main() {
Func();
} 複制
嚴重錯誤（非自願）：程序發生了嚴重的錯誤而不得不退出，通常是程式的錯誤導緻，例如執行了一條非法指令，引用不存在的記憶體，或者除數是0等，出現這些錯誤時程序預設會退出。而有些時候如果使用者想自行處理某種類型的錯誤，發生不同類型錯誤時程序會收到不同類型的信号，使用者注冊處理不同信号的函數即可。
被其它程序殺死（非自願）：其它程序執行kill系統調用通知作業系統殺死某個程序。
7
作業系統如何進行程序管理？
這裡就不得不提到一個資料結構：程序控制塊（PCB），作業系統為每個程序都維護一個PCB，用來儲存與該程序有關的各種狀态資訊。程序可以抽象了解為就是一個PCB，PCB是程序存在的唯一标志，作業系統用PCB來描述程序的基本情況以及運作變化的過程，程序的任何狀态變化都會通過PCB來展現。
PCB包含程序狀态的重要資訊，包括程式計數器、堆棧指針、記憶體配置設定狀況、所打開檔案的狀态、賬号和排程資訊，以及其它在程序由運作态轉換到就緒态或阻塞态時必須儲存的資訊，進而保證該程序随後能再次啟動，就像從未中斷過一樣。後一小節會具體介紹PCB。
提到程序管理，有一個概念我們必須要知道，就是中斷向量，中斷向量是指中斷服務程式的入口位址。一個程序在執行過程中可能會被中斷無數次，但是每次中斷後，被中斷的程序都要傳回到與中斷發生前完全相同的狀态。
中斷發生後作業系統最底層做了什麼呢？
1）硬體壓入堆棧程式計數器等；
2）硬體從中斷向量裝入新的程式計數器；
3）彙編語言過程儲存寄存器值；
4）彙編語言過程設定新的堆棧；
5）C中斷服務例程運作（典型的讀和緩沖輸入）；
6）排程程式決定下一個将運作的程序；
7）C過程傳回到彙編代碼；
8）彙編語言過程開始運作新的目前程序。
8
程序控制塊中存儲了什麼資訊？
程序辨別資訊：如本程序的辨別，本程序的父程序辨別，使用者辨別等。
處理機狀态資訊保護區：用于儲存程序的運作現場資訊。
- 使用者可見寄存器：使用者程式可以使用的資料、位址等寄存器。
- 控制和狀态寄存器：程式計數器，程式狀态字。
- 棧指針：過程調用、系統調用、中斷處理和傳回時需要用到它。
程序控制資訊：
- 排程和狀态資訊：用于作業系統排程程序使用。
- 程序間通信資訊：為支援程序間與通信相關的各種辨別、信号、信件等，這些資訊存在接收方的程序控制塊中。
- 存儲管理資訊：包含有指向本程序映像存儲空間的資料結構。
- 程序所用資源：說明由程序打開使用的系統資源，如打開的檔案等。
- 有關資料結構連接配接資訊：程序可以連接配接到一個程序隊列中，或連接配接到相關的其他程序的PCB。
9
程序如何進行生命周期管理？
程序建立：
建立程序有三個主要事件：
- 系統初始化
- 使用者請求建立一個新程序
- 一個正在運作的程序執行建立程序的系統調用
程序運作：核心選擇一個就緒的程序，讓它占用處理機并運作，這裡就涉及到了程序的排程政策，選擇哪個程序排程？為什麼選擇排程這個程序呢？（莫慌，下面會介紹哈）
程序等待：
在以下情況下程序會等待（阻塞）：
- 請求并等待系統服務，無法馬上完成
- 啟動某種操作，無法馬上完成
- 需要的資料沒有到達
注意：程序隻能自己阻塞自己，因為隻有程序自身才能知道何時需要等待某種事件的發生。
程序喚醒：
程序隻能被别的程序或作業系統喚醒，喚醒程序的原因有：
- 被阻塞程序需要的資源可被滿足
- 被阻塞程序等待的事件到達
- 将該程序的PCB插入到就緒隊列
程序結束：
在以下四種情況下程序會結束：
- 自願型正常退出
- 自願型錯誤退出
- 強制型緻命錯誤退出
- 強制型被其它程序殺死退出
10
程序都有什麼狀态？
不同系統設定的程序狀态是不同的，多數系統中的程序在生命結束前有三種基本狀态，程序隻會處于三種基本狀态之一：
運作狀态：程序正在處理機上運作時就處在運作狀态，該時刻程序時鐘占用着CPU；
就緒狀态：萬事俱備，隻欠東風，程序已經獲得了除處理機之外的一切所需資源，一旦得到處理機就可以運作；就緒态中的程序其實可以運作，但因為其它程序正在占用着CPU而暫時停止運作；
等待狀态（阻塞狀态）：程序正在等待某一事件而暫停運作，等待某個資源或者等待輸入輸出完成。除非某種外部事件發生，否則阻塞态的程序不能運作；
程序狀态變化圖如下：
在作業系統發現程序不能繼續運作下去時，程序因為等待輸入而被阻塞，程序從運作态轉換到阻塞态！
排程程式選擇了另一個程序執行時，目前程式就會從運作态轉換到就緒态！
被排程程式選擇的程式會從就緒态轉換到運作态！
當阻塞态的程序等待的一個外部事件發生時，就會從阻塞态轉換到就緒态，此時如果沒有其他程序運作時，則立刻從就緒态轉換到運作态！
有些與程序管理相關的系統調用讀者有必要了解一下：
pid=fork(); // 建立一個與父程序一樣的子程序
pid=waitpid(); // 等待子程序終止
s=execve(); // 替換程序的核心映像
exit(); // 終止程序運作并傳回狀态值
s=sigaction(); // 定義信号處理的動作
s=sigprocmask(); // 檢查或更換信号掩碼
s=sigpending(); // 獲得阻塞信号集合
s=sigsuspend(); // 替換信号掩碼或挂起程序
alarm(); // 設定定時器
pause(); // 挂起調用程式直到下一個信号出現 複制
某些系統設定下程序還會有其它狀态：
建立狀态：程序正在被建立還沒被轉到就緒狀态之前的狀态；
結束狀态：程序正在從系統中消失時的狀态。
1
1
什麼是程序挂起？為什麼會出現程序挂起？
程序挂起就是為了合理且充分的利用系統資源，把一個程序從記憶體轉到外存。程序在挂起狀态時，意味着程序沒有占用記憶體空間，處在挂起狀态的程序映射在磁盤上。程序挂起通常有兩種狀态：
- 阻塞挂起狀态：程序在外存并等待某事件的出現；
- 就緒挂起狀态：程序在外存，但隻要進入記憶體即可運作。
有什麼與程序挂起相關的狀态轉換？
程序挂起可能有以下幾種情況：
阻塞到阻塞挂起：沒有程序處于就緒狀态或就緒程序要求更多記憶體資源時，會進行這種轉換，以送出新程序或運作就緒程序；
就緒到就緒挂起：當有高優先級阻塞程序或低優先級就緒程序時，系統會選擇挂起低優先級就緒程序；
運作到就緒挂起：對于搶占式分時系統，當有高優先級阻塞挂起程序因事件出現而進入就緒挂起時，系統可能會把運作程序轉到就緒挂起狀态；
阻塞挂起到就緒挂起：當有阻塞挂起程序有相關事件出現時，系統會把阻塞挂起程序轉換為就緒挂起程序。
有程序挂起那就有程序解挂：指一個程序從外存轉到記憶體，相關狀态有：
就緒挂起到就緒：沒有就緒程序或就緒挂起程序優先級高于就緒程序時，就會進行這種轉換；
阻塞挂起到阻塞：當一個程序釋放足夠記憶體時，系統會把一個高優先級阻塞挂起程序轉換為阻塞程序。
1
2
什麼是程序排程？作業系統對于程序排程都有什麼政策？
當系統中有多個程序同時競争CPU，如果隻有一個CPU可用，那同一時刻隻會有一個程序處于運作狀态，作業系統必須要選擇下一個要運作的是哪個程序，在作業系統中，完成選擇工作的這部分稱為排程程式，該程式使用的算法稱作排程算法。
什麼時候進行排程？
- 系統調用建立一個新程序後，需要決定是運作父程序還是運作子程序。
- 一個程序退出時需要做出排程決策，需要決定下一個運作的是哪個程序。
- 當一個程序阻塞在I/O和信号量或者由于其它原因阻塞時，必須選擇另一個程序運作。
- 當一個I/O中斷發生時，如果中斷來自IO裝置，而該裝置現在完成了工作，某些被阻塞的等待該IO的程序就成為可運作的就緒程序了，是否讓新就緒的程序運作，或者讓中斷發生時運作的程序繼續運作，或者讓某個其它程序運作，這就取決于排程程式的抉擇了。
排程算法分類：
非搶占式排程算法：挑選一個程序，然後讓該程序運作直至被阻塞，或者直到該程序自動釋放CPU，即使該程序運作了若幹個小時，它也不會被強迫挂起。這樣做的結果是，在時鐘中斷發生時不會進行排程，在處理完時鐘中斷後，如果沒有更高優先級的程序等待，則被中斷的程序會繼續執行。簡單來說，排程程式必須等待事件結束。
非搶占方式引起程序排程的條件：
- 程序執行結束，或發生某個事件而不能繼續執行
- 正在運作的程序因有I/O請求而暫停執行
- 程序通信或同步過程中執行了某些原語操作（wait、block等）
搶占式排程算法：挑選一個程序，并且讓該程序運作某個固定時段的最大值。如果在該時段結束時，該程序仍在運作，它就被挂起，而排程程式挑選另一個程序運作，進行搶占式排程處理，需要在時間間隔的末端發生時鐘中斷，以便CPU控制傳回給排程程式，如果沒有可用的時鐘，那麼非搶占式排程就是唯一的選擇。簡單來說，就是目前運作的程序在事件沒結束時就可以被換出，防止單一程序長時間獨占CPU資源。下面會介紹很多搶占式排程算法：優先級算法、短作業優先算法、輪轉算法等。
排程政策：不同系統環境下有不同的排程政策算法。排程算法也是有KPI的，對排程算法首先提的需求就是：
- 公平：排程算法需要給每個程序公平的CPU份額，相似的程序應該得到相似的服務，對一個程序給予較其它等價的程序更多的CPU時間是不公平的，被普通水準的應屆生工資倒挂也是不公平的！
- 執行力：每一個政策必須強制執行，需要保證規定的政策一定要被執行。
- 平衡：需要保證系統的所有部分盡可能都忙碌。
但是因為不同的應用有不同的目标，不同的系統中，排程程式的優化也是不同的，大體可以分為三種環境：
批處理系統
批處理系統的管理者為了掌握系統的工作狀态，主要關注三個名額：
吞吐量：是系統每小時完成的作業數量
周轉時間：指從一個作業送出到完成的平均時間
CPU使用率：盡可能讓CPU忙碌，但又不能過量
排程算法：
先來先服務
先來後到嘛，就像平時去商店買東西需要排隊一樣，使用該算法，程序按照它們請求CPU的順序來使用CPU，該算法最大的優點就是簡單易于實作，太容易的不一定是好的，該算法也有很大的缺點：平均等待時間波動較大，時間短的任務可能排隊排在了時間長的任務後面。舉個生活中的例子，排着隊去取快遞，如果每個人都很快取出來快遞還好，如果前面有幾個人磨磨唧唧到快遞櫃前才拿出手機打開app，再找半分鐘它的取件碼，就會嚴重拖慢後面的人取快遞的速度，同理排着隊的程序如果每個程序都很快就運作完還好，如果其中有一個得到了CPU的程序運作時候磨磨唧唧很長時間都運作不完，那後面的程序基本上就沒有機會運作了！
最短作業優先
該排程算法是非搶占式的算法，每個程序執行期間不會被打斷，每次都選擇執行時間最短的程序來排程，但問題來了，作業系統怎麼可能知道程序具體的執行時間呢，是以該算法注定是基于預測性質的理想化算法，而且有違公平性，而且可能導緻運作時間長的任務得不到排程。
最短剩餘時間優先
該排程算法是搶占式的算法，是最短作業優先的搶占版本，在程序運作期間，如果來了個更短時間的程序，那就轉而去把CPU時間排程給這個更短時間的程序，它的缺點和最短作業優先算法類似。
互動式系統
對于互動系統最重要的名額就是響應時間和均衡性啦：
響應時間：一個請求被送出到産生第一次響應所花費的時間。你給别人發微信别人看後不回複你或者幾個小時後才回複你，你是什麼感受，這還是互動式嗎？
均衡性：減少平均響應時間的波動。需要符合固有期望和預期，你給别人發微信，他有時候秒回複，有時候幾個小時後才回複。在互動式系統中，可預測性比高差異低平均更重要。
排程算法：
輪轉排程
每個程序被配置設定一個時間段，稱為時間片，即CPU做到雨露均沾，輪流翻各個程序的牌子，這段時間寵幸程序A，下一段時間寵幸程序B，再下一段時間寵幸程序C，確定每個程序都可以獲得CPU時間，如果CPU時間特别短的話，在外部看來像是同時寵幸了所有程序一樣。那麼問題來了，這個時間片究竟多長時間好呢？如果時間片設的太短會導緻過多的程序切換，頻繁的上下文切換會降低CPU效率，而如果時間片設的太長又可能對短的互動請求的響應時間變長，通常将時間片設為20-50ms是個比較合理的折中，大佬們的經驗規則時維持上下文切換的開銷處于1%以内。
優先級排程
上面的輪轉排程算法是預設每個程序都同等重要，都有相同優先級，然而有時候程序需要設定優先級，例如某些播放視訊的前台程序可以優先于某些收發郵件的背景守護程序被排程，在優先級排程算法中，每個優先級都有相應的隊列，隊列裡面裝着對應優先級的程序，首先在高優先級隊列中進行輪轉排程，當高優先級隊列為空時，轉而去低優先級隊列中進行輪轉排程，如果高優先級隊列始終不為空，那麼低優先級的程序很可能就會饑餓到很久不能被排程。
多級隊列
多級隊列算法與優先級排程算法不同，優先級算法中每個程序配置設定的是相同的時間片，而在多級隊列算法中，不同隊列中的程序配置設定給不同的時間片，當一個程序用完配置設定的時間片後就移動到下一個隊列中，這樣可以更好的避免上下文頻繁切換。舉例：有一個程序需要100個時間片，如果每次排程都給配置設定一個時間片，則需要100次上下文切換，這樣CPU運作效率較低，通過多級隊列算法，可以考慮最開始給這個程序配置設定1個時間片，然後被換出，下次分給它2個時間片，再換出，之後分給它4、8、16、64個時間片，這樣配置設定的話，該程序隻需要7次交換就可以運作完成，相比100次上下文切換運作效率高了不少，但顧此就會失彼，那些需要互動的程序得到響應的速度就會下降。
最短程序優先
互動式系統中應用最短程序優先算法其實是非常适合的，每次都選擇執行時間最短的程序進行排程，這樣可以使任務的響應時間最短，但這裡有個任務，還沒有運作呢，我怎麼知道程序的運作時間呢？根本沒辦法非常準确的再目前可運作程序中找出最短的那個程序。有一種辦法就是根據程序過去的行為進行預測，但這能證明是個好辦法嗎？
保證排程
這種排程算法就是向使用者做出明确的可行的性能保證，然後去實作它。一種很實際的可實作的保證就是確定N個使用者中每個使用者都獲得CPU處理能力的1/N，類似的，保證N個程序中每個程序都獲得1/N的CPU時間。
彩票排程
彩票排程算法基本思想是為程序提供各種資源（CPU時間）的彩票，一旦需要做出排程決策時，就随機抽出一張彩票，擁有該彩票的程序獲得該資源，很明顯，擁有彩票越多的程序，獲得資源的可能性越大。該算法在程式喵看來可以了解為股票算法，将CPU的使用權分成若幹股，假設共100股分給了3個程序，給這些程序分别配置設定20、30、50股，那麼它們大體上會按照股權比例（20：30：50）劃分CPU的使用。
公平分享排程
假設有系統兩個使用者，使用者1啟動了1個程序，使用者2啟動了9個程序，如果使用輪轉排程算法，那麼使用者1将獲得10%的CPU時間，使用者2将獲得90%的CPU時間，這對使用者來說公平嗎？如果給每個使用者配置設定50%的CPU時間，那麼使用者2中的程序獲得的CPU時間明顯比使用者1中的程序短，這對程序來說公平嗎？這就取決于怎麼定義公平啦？
實時系統
實時系統顧名思義，最關鍵的名額當然是實時啦：
滿足截止時間：需要在規定deadline前完成作業；
可預測性：可預測性是指在系統運作的任何時刻，在任何情況下，實時系統的資源調配政策都能為争奪資源的任務合理的配置設定資源，使每個實時任務都能得到滿足。
排程算法分類：
硬實時
必須在deadline之前完成工作，如果delay，可能會發生災難性或發生嚴重的後果；
軟實時
必須在deadline之前完成工作，但如果偶爾delay了，也可以容忍。
排程算法：
單調速率排程
采用搶占式、靜态優先級的政策，排程周期性任務。
每個任務最開始都被配置好了優先級，當較低優先級的程序正在運作并且有較高優先級的程序可以運作時，較高優先級的程序将會搶占低優先級的程序。在進入系統時，每個周期性任務都會配置設定一個優先級，周期越短，優先級越高。這種政策的理由是：更頻繁的需要CPU的任務應該被配置設定更高的優先級。
最早截止時間排程
根據截止時間動态配置設定優先級，截止時間越早的程序優先級越高。
該算法中，當一個程序可以運作時，它應該向作業系統通知截止時間，根據截止時間的早晚，系統會為該程序調整優先級，以便滿足可運作程序的截止時間要求。它與單調速率排程算法的差別就是一個是靜态優先級，一個是動态優先級。
如何配置排程政策？
排程算法有很多種，各有優缺點，作業系統自己很少能做出最優的選擇，那麼可以把選擇權交給使用者，由使用者根據實際情況來選擇适合的排程算法，這就叫政策與機制分離，排程機制位于核心，排程政策由使用者程序決定，将排程算法以某種形式參數化，由使用者程序來選擇參數進而決定核心使用哪種排程算法。
13
作業系統怎麼完成程序排程？
程序的每次變化都會有相應的狀态，而作業系統維護了一組狀态隊列，表示系統中所有程序的目前狀态；不同的狀态有不同的隊列，有就緒隊列阻塞隊列等，每個程序的PCB都根據它的狀态加入到相應的隊列中，當一個程序的狀态發生變化時，它的PCB會從一個狀态隊列中脫離出來加入到另一個狀态隊列。
注意圖中同一種狀态為什麼有多個隊列呢？因為程序有優先級概念，相同狀态的不同隊列的優先級不同。
14
什麼是線程？
線程是程序當中的一條執行流程，這幾乎就是程序的定義，一個程序内可以有多個子執行流程，即線程。可以從兩個方面重新了解程序：
從資源組合的角度：程序把一組相關的資源組合起來，構成一個資源平台環境，包括位址空間（代碼段、資料段），打開的檔案等各種資源
從運作的角度：代碼在這個資源平台上的執行流程，然而線程貌似也是這樣，但是程序比線程多了資源内容清單樣式：那就有一個公式：程序 = 線程 + 共享資源
15
為什麼使用線程？
因為要并發程式設計，在許多情形中同時發生着許多活動，而某些活動有時候會被阻塞，通過将這些活動分解成可以準并行運作的多個順序流程是必須的，而如果使用多程序方式進行并發程式設計，程序間的通信也很複雜，并且維護程序的系統開銷較大：建立程序時配置設定資源建立PCB，撤銷程序時回收資源撤銷PCB，程序切換時儲存目前程序的狀态資訊。是以為了使并發程式設計的開銷盡量小，是以引入多線程程式設計，可以并發執行也可以共享相同的位址空間。并行實體擁有共享同一位址空間和所有可用資料的能力，這是多程序模型所不具備的能力。
使用線程有如下優點：
可以多個線程存在于同一個程序中
各個線程之間可以并發的執行
各個線程之間可以共享位址空間和檔案等資源
線程比程序更輕量級，建立線程撤銷線程比建立撤銷程序要快的多，在許多系統中，建立一個線程速度是建立一個程序速度的10-100倍。
如果多個線程是CPU密集型的，并不能很好的獲得更好的性能，但如果多個線程是IO密集型的，線程存在着大量的計算和大量的IO處理，有多個線程允許這些活動彼此重疊進行，進而會加快整體程式的執行速度。
但也有缺點：
一旦一個線程崩潰，會導緻其所屬程序的所有線程崩潰。
由于各個線程共享相同的位址空間，那麼讀寫資料可能會導緻競争關系，是以對同一塊資料的讀寫需要采取某些同步機制來避免線程不安全問題。
16
什麼時候用程序、線程？
- 程序是資源配置設定機關，線程是CPU排程機關；
- 程序擁有一個完整的資源平台，而線程隻獨享必不可少的資源，如寄存器和棧；
- 線程同樣具有就緒阻塞和執行三種基本狀态，同樣具有狀态之間的轉換關系；
- 線程能減少并發執行的時間和空間開銷：
- 線程的建立時間比程序短
- 線程的終止時間比程序短
- 同一程序内的線程切換時間比程序短
- 由于同一程序的各線程間共享記憶體和檔案資源，可直接進行不通過核心的通信
結論：可以在強調性能時候使用線程，如果追求更好的容錯性可以考慮使用多程序，google浏覽器據說就是用的多程序程式設計。在多CPU系統中，多線程是有益的，在這樣的系統中，通常情況下可以做到真正的并行。
C/C++中如何使用多線程程式設計？
POSIX使用如下線程封裝函數來操作線程：
pthread_create 建立一個新線程
pthread_exit 結束調用的線程
pthread_join 等待一個特定的線程退出
pthread_yield 釋放CPU來運作另外一個線程
pthread_attr_init 建立并初始化一個線程的屬性結構
pthread_attr_destroy 删除一個線程的屬性結構 複制
後兩個函數是有關線程屬性的調用。pthread_attr_init建立關聯一個線程的屬性結構并初始化成預設值，這些值（優先級等）可以通過修改屬性結構中的對應值來改變；pthread_attr_destroy會删除一個線程的屬性結構，釋放它占用的記憶體，它不會影響調用它的線程，線程依然會繼續存在。
C++中有std::thread和async，可以很友善地操作多線程，示例代碼如下：
void F() {
cout << "a" << endl;
}
int main() {
std::thread r(F);
r.detach();
std::this_thread::sleep_for(std::chrono::seconds(20));
return 0;
} 複制
17
線程是如何實作的？
線程的實作可分為使用者線程和核心線程：
使用者線程：在使用者空間實作的線程機制，它不依賴于作業系統的核心，由一組使用者級的線程庫函數來完成線程的管理，包括程序的建立終止同步和排程等。
使用者線程有如下優點：
由于使用者線程的維護由相應程序來完成（通過線程庫函數），不需要作業系統核心了解核心了解使用者線程的存在，可用于不支援線程技術的多程序作業系統。
每個程序都需要它自己私有的線程控制塊清單，用來跟蹤記錄它的各個線程的狀态資訊（PC，棧指針，寄存器），TCB由線程庫函數來維護；
使用者線程的切換也是由線程庫函數來完成，無需使用者态/核心态切換，是以速度特别快；
允許每個程序擁有自定義的線程排程算法；
但使用者線程也有缺點：
阻塞性的系統調用如何實作？如果一個線程發起系統調用而阻塞，則整個程序在等待。
當一個線程開始運作後，除非它主動交出CPU的使用權，否則它所在程序當中的其它線程将無法運作；
由于時間片配置設定給程序，與其它程序比，在多線程執行時，每個線程得到的時間片較少，執行會較慢
核心線程：是指在作業系統的核心中實作的一種線程機制，由作業系統的核心來完成線程的建立終止和管理。
特點：
在支援核心線程的作業系統中，由核心來維護程序和線程的上下文資訊（PCB TCB）；
線程的建立終止和切換都是通過系統調用核心函數的方式來進行，由核心來完成，是以系統開銷較大；
在一個程序當中，如果某個核心線程發起系統調用而被阻塞，并不會影響其它核心線程的運作；
時間片配置設定給線程，多線程的程序獲得更多CPU時間；
tips
由于在核心中建立或撤銷線程的代價比較大，某些系統采取複用的方式回收線程，當某個線程被撤銷時，就把它标記不可運作，但是核心資料結構沒有受到任何影響，如果後續又需要建立一個新線程時，就重新啟動被标記為不可運作的舊線程，進而節省一些開銷。
注意
盡管使用核心線程可以解決很多問題，但還有些問題，例如：當一個多線程的程序建立一個新的程序時會發生什麼？新程序是擁有與原程序相同數量的線程還是隻有一個線程？在很多情況下，最好的選擇取決于程序計劃下一步做什麼？如果它要調用exec啟動一個新程式，或許一個線程正合适，但如果它繼續運作，那麼最好複制所有的線程。
輕量級程序：它是核心支援的使用者線程模型，一個程序可以有多個輕量級程序，每個輕量級程序由一個單獨的核心線程來支援。
在Linux下是沒有真正的線程的，它所謂的線程其實就是使用程序來實作的，就是所謂的輕量級程序，其實就是程序，都是通過clone接口調用建立的，隻不過兩者傳遞的參數不同，通過參數決定子程序和父程序共享的資源種類和數量，進而有了普通程序和輕量級程序的差別。
18
什麼是上下文切換？
上下文切換指的是作業系統停止目前運作程序（從運作狀态改變成其它狀态）并且排程其它程序（就緒态轉變成運作狀态）。作業系統必須在切換之前存儲許多部分的程序上下文，必須能夠在之後恢複他們，是以程序不能顯示它曾經被暫停過，同時切換上下文這個過程必須快速，因為上下文切換操作是非常頻繁的。那上下文指的是什麼呢？指的是任務所有共享資源的工作現場，每一個共享資源都有一個工作現場，包括用于處理函數調用、局部變量配置設定以及工作現場保護的棧頂指針，和用于指令執行等功能的各種寄存器。
注意
這裡所說的程序切換導緻上下文切換其實不太準确，準确的說應該是任務的切換導緻上下文切換，這裡的任務可以是程序也可以是線程，準确的說線程才是CPU排程的基本機關，但是因為各個資料都這麼解釋上下文切換，是以上面也暫時這麼介紹，隻要讀者心裡有這個概念就好。
19
程序間通信有幾種方式？
由于各個程序不共享相同的位址空間，任何一個程序的全局變量在另一個程序中都不可見，是以如果想要在程序之間傳遞資料就需要通過核心，在核心中開辟出一塊區域，該區域對多個程序都可見，即可用于程序間通信。有讀者可能有疑問了，檔案方式也是程序間通信啊，也要在核心開辟區域嗎？這裡說的核心區域其實是一段緩沖區，檔案方式傳輸資料也有核心緩沖區的參與（零拷貝除外）。
如何開辟這種公共區域來進行程序間通信呢？
匿名管道
匿名管道就是pipe，pipe隻能在父子程序間通信，而且資料隻能單向流動（半雙工通信）。
使用方式：
1）父程序建立管道，會得到兩個檔案描述符，分别指向管道的兩端；
2）父程序建立子程序，進而子程序也有兩個檔案描述符指向同一管道；
3）父程序可寫資料到管道，子程序就可從管道中讀出資料，進而實作程序間通信，下面的示例代碼中通過pipe實作了每秒鐘父程序向子程序都發送消息的功能。
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int main() {
int _pipe[2];
int ret = pipe(_pipe);
if (ret < 0) {
perror("pipe\n");
}
pid_t id = fork();
if (id < 0) {
perror("fork\n");
} else if (id == 0) { // 子程序
close(_pipe[1]);
int j = 0;
char _mesg[100];
while (j < 100) {
memset(_mesg, '\0', sizeof(_mesg));
read(_pipe[0], _mesg, sizeof(_mesg));
printf("%s\n", _mesg);
j++;
}
} else { // 父程序
close(_pipe[0]);
int i = 0;
char *mesg = NULL;
while (i < 100) {
mesg = "父程序來寫消息了";
write(_pipe[1], mesg, strlen(mesg) + 1);
sleep(1);
++i;
}
}
return 0;
} 複制
我們平時也經常使用關于管道的指令行：
ls | less 複制
該指令行的流向圖如下：
1：建立管道
2：為ls建立一個程序，設定stdout為管理寫端
3：為less建立一個程序，設定stdin為管道讀端
進階管道
通過popen将另一個程式當作一個新的程序在目前程序中啟動，它算作目前程序的子程序，進階管道隻能用在有親緣關系的程序間通信，這種親緣關系通常指父子程序，下面的GetCmdResult函數可以擷取某個Linux指令執行的結果，實作方式就是通過popen。
std::string GetCmdResult(const std::string &cmd, int max_size = 10240) {
char *data = (char *)malloc(max_size);
if (data == NULL) {
return std::string("malloc fail");
}
memset(data, 0, max_size);
const int max_buffer = 256;
char buffer[max_buffer];
// 将标準錯誤重定向到标準輸出
FILE *fdp = popen((cmd + " 2>&1").c_str(), "r");
int data_len = 0;
if (fdp) {
while (!feof(fdp)) {
if (fgets(buffer, max_buffer, fdp)) {
int len = strlen(buffer);
if (data_len + len > max_size) {
cout << "data size larger than " << max_size;
break;
}
memcpy(data + data_len, buffer, len);
data_len += len;
}
}
pclose(fdp);
}
std::string ret(data, data_len);
free(data);
return ret;
} 複制
命名管道
匿名管道有個缺點就是通信的程序一定要有親緣關系，而命名管道就不需要這種限制。
命名管道其實就是一種特殊類型的檔案，所謂的命名其實就是檔案名，檔案對各個程序都可見，通過命名管道建立好特殊檔案後，就可以實作程序間通信。
可以通過mkfifo建立一個特殊的類型的檔案，參數讀者看名字應該就了解，一個是檔案名，一個是檔案的讀寫權限：
int mkfifo(const char* filename, mode_t mode); 複制
當傳回值為0時，表示該命名管道建立成功，至于如何通信，其實就是個讀寫檔案的問題！
消息隊列
隊列想必大家都知道，像FIFO一樣，這裡可以有多個程序寫入資料，也可以有多個程序從隊列裡讀出資料，但消息隊列有一點比FIFO還更進階，它讀消息不一定要使用先進先出的順序，每個消息可以賦予類型，可以按消息的類型讀取，不是指定類型的資料還存在隊列中。本質上MessageQueue是存放在核心中的消息連結清單，每個消息隊列連結清單會由消息隊列辨別符表示，這個消息隊列存于核心中，隻有主動的删除該消息隊列或者核心重新開機時，消息隊列才會被删除。
在Linux中消息隊列相關的函數調用如下：
// 建立和通路一個消息隊列
int msgget(key_t, key, int msgflg);
// 用來把消息添加到消息隊列中
int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);
// msg_ptr是結構體資料的指針，結構第一個字段要有個類型：struct Msg {
long int message_type;
// 想要傳輸的資料
};
// 從消息隊列中擷取消息
int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);
// 用來控制消息隊列，不同的command參數有不同的控制方式
int msgctl(int msgid, int command, struct msgid_ds *buf); 複制
示例代碼如下：
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/msg.h>
#include <chrono>
#include <iostream>
#include <thread>
using namespace std;
#define BUFFER_SIZ 20
typedef struct {
long int msg_type;
char text[BUFFER_SIZ];
} MsgWrapper;
void Receive() {
MsgWrapper data;
long int msgtype = 2;
int msgid = msgget((key_t)1024, 0666 | IPC_CREAT);
if (msgid == -1) {
cout << "msgget error \n";
return;
}
while (true) {
if (msgrcv(msgid, (void *)&data, BUFFER_SIZ, msgtype, 0) == -1) {
cout << "error " << errno << endl;
}
cout << "read data " << data.text << endl;
if (strlen(data.text) > 6) { // 發送超過6個字元的資料，結束
break;
}
}
if (msgctl(msgid, IPC_RMID, 0) == -1) {
cout << "msgctl error \n";
}
cout << "Receive ok \n";
}
void Send() {
MsgWrapper data;
long int msgtype = 2;
int msgid = msgget((key_t)1024, 0666 | IPC_CREAT);
if (msgid == -1) {
cout << "msgget error \n";
return;
}
data.msg_type = msgtype;
for (int i = 0; i < 10; ++i) {
memset(data.text, 0, BUFFER_SIZ);
char a = 'a' + i;
memset(data.text, a, 1);
if (msgsnd(msgid, (void *)&data, BUFFER_SIZ, 0) == -1) {
cout << "msgsnd error \n";
return;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
}
memcpy(data.text, "1234567", 7);
if (msgsnd(msgid, (void *)&data, BUFFER_SIZ, 0) == -1) {
cout << "msgsnd error \n";
return;
}
}
int main() {
std::thread r(Receive);
r.detach();
std::thread s(Send);
s.detach();
std::this_thread::sleep_for(std::chrono::seconds(20));
return 0;
}
輸出：root@iZuf64idor3ej648ciairaZ:~# ./a.out
read data a
read data b
read data c
read data d
read data e
read data f
read data g
read data h
read data i
read data j
read data 1234567
Receive ok 複制
代碼中為了示範友善使用消息隊列進行的線程間通信，該代碼同樣用于程序間通信，消息隊列的實作依賴于核心的支援，上述代碼可能在某些系統（WSL）上不能運作，在正常的Ubuntu上可以正常運作。
消息隊列VS命名管道
消息隊列>命名管道
1）消息隊列收發消息自動保證了同步，不需要由程序自己來提供同步方法，而命名管道需要自行處理同步問題；
2）消息隊列接收資料可以根據消息類型有選擇的接收特定類型的資料，不需要像命名管道一樣預設接收資料。
消息隊列<命名管道
消息隊列有一個缺點就是發送和接收的每個資料都有最大長度的限制。
共享記憶體
可開辟中一塊記憶體，用于各個程序間共享，使得各個程序可以直接讀寫同一塊記憶體空間，就像線程共享同一塊位址空間一樣，該方式基本上是最快的程序間通信方式，因為沒有系統調用幹預，也沒有資料的拷貝操作，但由于共享同一塊位址空間，資料競争的問題就會出現，需要自己引入同步機制解決資料競争問題。
共享記憶體隻是一種方式，它的實作方式有很多種，主要的有mmap系統調用、Posix共享記憶體以及System V共享記憶體等。通過這三種“工具”共享位址空間後，通信的目的自然就會達到。
信号
信号也是程序間通信的一種方式，信号可以在任何時候發送給某一個程序，如果程序目前并未處于執行狀态，核心将信号儲存，直到程序恢複到執行态再發送給程序，程序可以對信号設定預處理方式，如果對信号設定了阻塞處理，則信号的傳遞會被延遲直到阻塞被取消，如果程序結束，那信号就被丢棄。我們常用的CTRL+C和kill等就是信号的一種，也達到了程序間通信的目的，程序也可以對信号設定signal捕獲函數自定義處理邏輯。這種方式有很大的缺點：隻有通知的作用，通知了一下消息的類型，但不能傳輸要交換的任何資料。
Linux系統中常見的信号有：
SIGHUP：該信号在使用者終端結束時發出，通常在中斷的控制程序結束時，所有程序組都将收到該信号，該信号的預設操作是終止程序；
SIGINT：程式終止信号，通常的CTRL+C産生該信号來通知終止程序；
SIGQUIT：類似于程式錯誤信号，通常的CTRL+\産生該信号通知程序退出時産生core檔案；
SIGILL：執行了非法指令，通常資料段或者堆棧溢出可能産生該信号；
SIGTRAP：供調試器使用，由斷電指令或其它陷阱指令産生；
SIGABRT：使程式非正常結束，調用abort函數會産生該信号；
SIGBUS：非法位址，通常是位址對齊問題導緻，比如通路一個4位元組長的整數，但其位址不是4的倍數；
SIGSEGV：合理位址的非法通路，通路了未配置設定的記憶體或者沒有權限的記憶體區域；
SIGPIPE：管道破裂信号，socket通信時經常會遇到，程序寫入了一個無讀者的管道；
SIGALRM：時鐘定時信号，由alarm函數設定的時間終止時産生；
SIGFPE：出現浮點錯誤（比如除0操作）；
SIGKILL：殺死程序（不能被捕捉和忽略）；
信号量
想必大家都聽過信号量，信号量就是一個特殊的變量，程式對其通路都是原子操作，每個信号量開始都有個初始值。最簡單最常見的信号量是隻能取0和1的變量，也叫二值信号量。
信号量有兩個操作，P和V：
P：如果信号量變量值大于0，則變量值減1，如果值為0，則阻塞程序；
V：如果有程序阻塞在該信号量上，則喚醒阻塞的程序，如果沒有程序阻塞，則變量值加1
Q
信号量和信号有什麼關系？
A
沒有任何關系，完全是不同的東西。
Q
信号量與互斥量有什麼差別？
A
互斥量用于互斥，信号量用于同步，互斥指的是某一資源同一時間隻允許一個通路者通路，但無法限制通路順序，通路是無序的，而同步在互斥的基礎上可以控制通路者對資源的順序。
套接字：就是網絡傳輸，不用多說，網絡通信都可以多機通信呢，更不用說程序間通信啦，你能看到程式喵的文章也是套接字的功勞。
檔案：顯而易見，多個程序可以操作同一個檔案，是以也可以通過檔案來進行程序間通信。
參考資料
- https://cloud.tencent.com/developer/article/1339562
- https://blog.csdn.net/gatieme/article/details/51481863
- https://blog.csdn.net/sddxqlrjxr/article/details/51249619
- 《現代作業系統》
- 《B站清華作業系統教學視訊》
- 《B站哈工大作業系統教學視訊》