面試官：進程和線程，我只問這 19 個問題

什麼是進程？

**標準定義：**進程是一個具有一定獨立功能的程序在一個數據集合上依次動態執行的過程。進程是一個正在執行程序的實例，包括程序計數器、寄存器和程序變量的當前值。

簡單來說進程就是一個程序的執行流程，內部保存程序運行所需的資源。

在操作系統中可以有多個進程在運行，可對於 CPU 來說，同一時刻，一個 CPU 只能運行一個進程，但在某一時間段內，CPU 將這一時間段拆分成更短的時間片，CPU 不停的在各個進程間遊走，這就給人一種並行的錯覺，像 CPU 可以同時運行多個進程一樣，這就是僞並行。

進程和程序有什麼聯繫？

一個進程是某種類型的一個活動，它有程序、輸入、輸出以及狀態。單個處理器可以被若干進程共享，它使用某種調度算法決定何時停止一個進程的工作，並轉而爲另一個進程提供服務。

程序是產生進程的基礎

程序的每次運行產生不同的進程

進程是程序功能的體現

通過多次執行，一個程序可對應多個進程；通過調用關係，一個進程可包括多個程序

進程和程序有什麼區別？

進程是動態的，程序是靜態的：程序是有序代碼的集合，進程是程序的執行。

進程是暫時的，程序是永久的：進程是一個狀態變化的過程，程序可長久保存。

進程和程序的組成不同：進程的組成包括程序、數據和進程控制塊（進程狀態信息）。

進程有什麼特點？

動態性：可動態的創建和結束進程

併發性：可以被獨立的調度並佔用處理機併發運行

獨立性：不同進程的工作不相互影響

制約性：因訪問共享資源或進程間同步而產生制約

進程如何創建？

有什麼事件會觸發進程的創建呢？

系統初始化：當啓動操作系統時，通常會創建很多進程，有些是同用戶交互並替他們完成工作的前臺進程，其它的都是後臺進程，後臺進程和特定用戶沒有關係，但也提供某些專門的功能，例如接收郵件等，這種功能的進程也稱爲守護進程。計劃任務是個典型的守護進程，它每分鐘運行一次來檢查是否有工作需要它完成。如果有工作要做，它就會完成此工作，然後進入休眠狀態，直到下一次檢查時刻的到來。

正在運行的程序執行了創建進程的系統調用：在一個進程中又創建了一個新的進程，這種情況很常見。

用戶請求創建一個新進程：這種情況相信每個人都見過，用電腦時雙擊某個應用圖標，就會有至少一個進程被創建。

一個批處理作業的初始化：這種情形不常見，僅在大型機的批處理系統中應用，用戶在這種系統中提交批處理作業，在操作系統認爲有資源可運行另一個作業時，它創建一個新的進程，並運行其輸入隊列中的下一個作業。

歸根到底：在 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 的實現使程序正文在兩者間共享，因爲它是不可修改的。

還有一種寫時複製共享技術，子進程共享父進程的所有內存，一旦兩者之一想要修改部分內存，則這塊內存被複制確保修改發生在當前進程的私有內存區域。

進程爲何終止？

有什麼事件會觸發進程的終止呢？

正常退出（自願）：進程完成了工作正常終止，UNIX 中退出進程的系統調用是 exit。

出錯退出（自願）：進程發現了錯誤而退出。可以看如下代碼：

#include <stdio.h>
#include <stdlib.h>
void Func() {
    if (error) { // 有錯誤就退出程序
        exit(1);
    }
}
int main() {
    Func();
}

嚴重錯誤（非自願）：進程發生了嚴重的錯誤而不得不退出，通常是程序的錯誤導致，例如執行了一條非法指令，引用不存在的內存，或者除數是 0 等，出現這些錯誤時進程默認會退出。而有些時候如果用戶想自行處理某種類型的錯誤，發生不同類型錯誤時進程會收到不同類型的信號，用戶註冊處理不同信號的函數即可。

被其它進程殺死（非自願）：其它進程執行 kill 系統調用通知操作系統殺死某個進程。

操作系統如何進行進程管理？

這裏就不得不提到一個數據結構：進程控制塊（PCB），操作系統爲每個進程都維護一個 PCB，用來保存與該進程有關的各種狀態信息。進程可以抽象理解爲就是一個 PCB，PCB 是進程存在的唯一標誌，操作系統用 PCB 來描述進程的基本情況以及運行變化的過程，進程的任何狀態變化都會通過 PCB 來體現。

PCB 包含進程狀態的重要信息，包括程序計數器、堆棧指針、內存分配狀況、所打開文件的狀態、賬號和調度信息，以及其它在進程由運行態轉換到就緒態或阻塞態時必須保存的信息，從而保證該進程隨後能再次啓動，就像從未中斷過一樣。後一小節會具體介紹 PCB。

提到進程管理，有一個概念我們必須要知道，就是中斷向量，中斷向量是指中斷服務程序的入口地址。一個進程在執行過程中可能會被中斷無數次，但是每次中斷後，被中斷的進程都要返回到與中斷髮生前完全相同的狀態。

中斷髮生後操作系統最底層做了什麼呢？

1）硬件壓入堆棧程序計數器等；

2）硬件從中斷向量裝入新的程序計數器；

3）彙編語言過程保存寄存器值；

4）彙編語言過程設置新的堆棧；

5）C 中斷服務例程運行（典型的讀和緩衝輸入）；

6）調度程序決定下一個將運行的進程；

7）C 過程返回到彙編代碼；

8）彙編語言過程開始運行新的當前進程。

進程控制塊中存儲了什麼信息？

進程標識信息：如本進程的標識，本進程的父進程標識，用戶標識等。

處理機狀態信息保護區：用於保存進程的運行現場信息：

用戶可見寄存器：用戶程序可以使用的數據，地址等寄存器
控制和狀態寄存器：程序計數器，程序狀態字
棧指針：過程調用、系統調用、中斷處理和返回時需要用到它

進程控制信息：

調度和狀態信息：用於操作系統調度進程使用
進程間通信信息：爲支持進程間與通信相關的各種標識、信號、信件等，這些信息存在接收方的進程控制塊中
存儲管理信息：包含有指向本進程映像存儲空間的數據結構
進程所用資源：說明由進程打開使用的系統資源，如打開的文件等
有關數據結構連接信息：進程可以連接到一個進程隊列中，或連接到相關的其他進程的 PCB

進程如何進行生命週期管理？

進程創建：

創建進程有三個主要事件：

系統初始化
用戶請求創建一個新進程
一個正在運行的進程執行創建進程的系統調用

進程運行：內核選擇一個就緒的進程，讓它佔用處理機並運行，這裏就涉及到了進程的調度策略，選擇哪個進程調度？爲什麼選擇調度這個進程呢？（莫慌，下面會介紹哈）

進程等待：

在以下情況下進程會等待（阻塞）：

請求並等待系統服務，無法馬上完成
啓動某種操作，無法馬上完成
需要的數據沒有到達。

注意：進程只能自己阻塞自己，因爲只有進程自身才能知道何時需要等待某種事件的發生。

進程喚醒：

進程只能被別的進程或操作系統喚醒，喚醒進程的原因有：

被阻塞進程需要的資源可被滿足
被阻塞進程等待的事件到達
將該進程的 PCB 插入到就緒隊列

進程結束：

在以下四種情況下進程會結束：

自願型正常退出
自願型錯誤退出
強制型致命錯誤退出
強制型被其它進程殺死退出

進程都有什麼狀態？

不同系統設置的進程狀態是不同的，多數系統中的進程在生命結束前有三種基本狀態，進程只會處於三種基本狀態之一：

運行狀態：進程正在處理機上運行時就處在運行狀態，該時刻進程時鐘佔用着 CPU；

就緒狀態：萬事俱備，只欠東風，進程已經獲得了除處理機之外的一切所需資源，一旦得到處理機就可以運行；就緒態中的進程其實可以運行，但因爲其它進程正在佔用着 CPU 而暫時停止運行；

等待狀態（阻塞狀態）：進程正在等待某一事件而暫停運行，等待某個資源或者等待輸入輸出完成。除非某種外部事件發生，否則阻塞態的進程不能運行；

進程狀態變化圖如下：

在操作系統發現進程不能繼續運行下去時，進程因爲等待輸入而被阻塞，進程從運行態轉換到阻塞態！

調度程序選擇了另一個進程執行時，當前程序就會從運行態轉換到就緒態！

被調度程序選擇的程序會從就緒態轉換到運行態！

當阻塞態的進程等待的一個外部事件發生時，就會從阻塞態轉換到就緒態，此時如果沒有其他進程運行時，則立刻從就緒態轉換到運行態！

某些系統設置下進程還會有其它狀態：

創建狀態：進程正在被創建還沒被轉到就緒狀態之前的狀態；

結束狀態：進程正在從系統中消失時的狀態。

有些與進程管理相關的系統調用讀者有必要了解一下：

pid=fork(); // 創建一個與父進程一樣的子進程
pid=waitpid(); // 等待子進程終止
s=execve(); // 替換進程的核心映像
exit(); // 終止進程運行並返回狀態值
s=sigaction(); // 定義信號處理的動作
s=sigprocmask(); // 檢查或更換信號掩碼
s=sigpending(); // 獲得阻塞信號集合
s=sigsuspend(); // 替換信號掩碼或掛起進程
alarm(); // 設置定時器
pause(); // 掛起調用程序直到下一個信號出現

什麼是進程掛起？爲什麼會出現進程掛起？

進程掛起就是爲了合理且充分的利用系統資源，把一個進程從內存轉到外存。進程在掛起狀態時，意味着進程沒有佔用內存空間，處在掛起狀態的進程映射在磁盤上。進程掛起通常有兩種狀態：

阻塞掛起狀態：進程在外存並等待某事件的出現；
就緒掛起狀態：進程在外存，但只要進入內存即可運行。

有什麼與進程掛起相關的狀態轉換？

進程掛起可能有以下幾種情況：

阻塞到阻塞掛起：沒有進程處於就緒狀態或就緒進程要求更多內存資源時，會進行這種轉換，以提交新進程或運行就緒進程；

就緒到就緒掛起：當有高優先級阻塞進程或低優先級就緒進程時，系統會選擇掛起低優先級就緒進程；

運行到就緒掛起：對於搶佔式分時系統，當有高優先級阻塞掛起進程因事件出現而進入就緒掛起時，系統可能會把運行進程轉到就緒掛起狀態；

阻塞掛起到就緒掛起：當有阻塞掛起進程有相關事件出現時，系統會把阻塞掛起進程轉換爲就緒掛起進程。

有進程掛起那就有進程解掛：指一個進程從外存轉到內存，相關狀態有：

就緒掛起到就緒：沒有就緒進程或就緒掛起進程優先級高於就緒進程時，就會進行這種轉換；

阻塞掛起到阻塞：當一個進程釋放足夠內存時，系統會把一個高優先級阻塞掛起進程轉換爲阻塞進程。

什麼是進程調度？操作系統對於進程調度都有什麼策略？

當系統中有多個進程同時競爭 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 的任務應該被分配更高的優先級。

最早截止時間調度

根據截止時間動態分配優先級，截止時間越早的進程優先級越高。

該算法中，當一個進程可以運行時，它應該向操作系統通知截止時間，根據截止時間的早晚，系統會爲該進程調整優先級，以便滿足可運行進程的截止時間要求。它與單調速率調度算法的區別就是一個是靜態優先級，一個是動態優先級。

如何配置調度策略？

調度算法有很多種，各有優缺點，操作系統自己很少能做出最優的選擇，那麼可以把選擇權交給用戶，由用戶根據實際情況來選擇適合的調度算法，這就叫策略與機制分離，調度機制位於內核，調度策略由用戶進程決定，將調度算法以某種形式參數化，由用戶進程來選擇參數從而決定內核使用哪種調度算法。

操作系統怎麼完成進程調度？

進程的每次變化都會有相應的狀態，而操作系統維護了一組狀態隊列，表示系統中所有進程的當前狀態；不同的狀態有不同的隊列，有就緒隊列阻塞隊列等，每個進程的 PCB 都根據它的狀態加入到相應的隊列中，當一個進程的狀態發生變化時，它的 PCB 會從一個狀態隊列中脫離出來加入到另一個狀態隊列。

注意圖中同一種狀態爲什麼有多個隊列呢？因爲進程有優先級概念，相同狀態的不同隊列的優先級不同。

什麼是線程？

線程是進程當中的一條執行流程，這幾乎就是進程的定義，一個進程內可以有多個子執行流程，即線程。可以從兩個方面重新理解進程：

從資源組合的角度：進程把一組相關的資源組合起來，構成一個資源平臺環境，包括地址空間（代碼段、數據段），打開的文件等各種資源

從運行的角度：代碼在這個資源平臺上的執行流程，然而線程貌似也是這樣，但是進程比線程多了資源內容列表樣式：那就有一個公式：進程 = 線程 + 共享資源

爲什麼使用線程？

因爲要併發編程，在許多情形中同時發生着許多活動，而某些活動有時候會被阻塞，通過將這些活動分解成可以準並行運行的多個順序流程是必須的，而如果使用多進程方式進行併發編程，進程間的通信也很複雜，並且維護進程的系統開銷較大：創建進程時分配資源建立 PCB，撤銷進程時回收資源撤銷 PCB，進程切換時保存當前進程的狀態信息。所以爲了使併發編程的開銷儘量小，所以引入多線程編程，可以併發執行也可以共享相同的地址空間。並行實體擁有共享同一地址空間和所有可用數據的能力，這是多進程模型所不具備的能力。

使用線程有如下優點：

可以多個線程存在於同一個進程中

各個線程之間可以併發的執行

各個線程之間可以共享地址空間和文件等資源

線程比進程更輕量級，創建線程撤銷線程比創建撤銷進程要快的多，在許多系統中，創建一個線程速度是創建一個進程速度的 10-100 倍。

如果多個線程是 CPU 密集型的，並不能很好的獲得更好的性能，但如果多個線程是 IO 密集型的，線程存在着大量的計算和大量的 IO 處理，有多個線程允許這些活動彼此重疊進行，從而會加快整體程序的執行速度。

但也有缺點：

一旦一個線程崩潰，會導致其所屬進程的所有線程崩潰。

由於各個線程共享相同的地址空間，那麼讀寫數據可能會導致競爭關係，因此對同一塊數據的讀寫需要採取某些同步機制來避免線程不安全問題。

什麼時候用進程、線程？

進程是資源分配單位，線程是 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;
}

想了解更多關於 C++ 線程相關的知識點可以看：

c++11 新特性，所有知識點都在這了！

線程是如何實現的？

線程的實現可分爲用戶線程和內核線程：

用戶線程：在用戶空間實現的線程機制，它不依賴於操作系統的內核，由一組用戶級的線程庫函數來完成線程的管理，包括進程的創建終止同步和調度等。

用戶線程有如下優點：

由於用戶線程的維護由相應進程來完成（通過線程庫函數），不需要操作系統內核瞭解內核瞭解用戶線程的存在，可用於不支持線程技術的多進程操作系統。

每個進程都需要它自己私有的線程控制塊列表，用來跟蹤記錄它的各個線程的狀態信息（PC，棧指針，寄存器），TCB 由線程庫函數來維護；

用戶線程的切換也是由線程庫函數來完成，無需用戶態 / 核心態切換，所以速度特別快；

允許每個進程擁有自定義的線程調度算法；

但用戶線程也有缺點：

阻塞性的系統調用如何實現？如果一個線程發起系統調用而阻塞，則整個進程在等待。

當一個線程開始運行後，除非它主動交出 CPU 的使用權，否則它所在進程當中的其它線程將無法運行；

由於時間片分配給進程，與其它進程比，在多線程執行時，每個線程得到的時間片較少，執行會較慢

內核線程：是指在操作系統的內核中實現的一種線程機制，由操作系統的內核來完成線程的創建終止和管理。

特點：

在支持內核線程的操作系統中，由內核來維護進程和線程的上下文信息（PCB TCB）；

線程的創建終止和切換都是通過系統調用內核函數的方式來進行，由內核來完成，因此係統開銷較大；

在一個進程當中，如果某個內核線程發起系統調用而被阻塞，並不會影響其它內核線程的運行；

時間片分配給線程，多線程的進程獲得更多 CPU 時間；

tips

由於在內核中創建或撤銷線程的代價比較大，某些系統採取複用的方式回收線程，當某個線程被撤銷時，就把它標記不可運行，但是內核數據結構沒有受到任何影響，如果後續又需要創建一個新線程時，就重新啓動被標記爲不可運行的舊線程，從而節省一些開銷。

注意

儘管使用內核線程可以解決很多問題，但還有些問題，例如：當一個多線程的進程創建一個新的進程時會發生什麼？新進程是擁有與原進程相同數量的線程還是隻有一個線程？在很多情況下，最好的選擇取決於進程計劃下一步做什麼？如果它要調用 exec 啓動一個新程序，或許一個線程正合適，但如果它繼續運行，那麼最好複製所有的線程。

輕量級進程：它是內核支持的用戶線程模型，一個進程可以有多個輕量級進程，每個輕量級進程由一個單獨的內核線程來支持。

在 Linux 下是沒有真正的線程的，它所謂的線程其實就是使用進程來實現的，就是所謂的輕量級進程，其實就是進程，都是通過 clone 接口調用創建的，只不過兩者傳遞的參數不同，通過參數決定子進程和父進程共享的資源種類和數量，進而有了普通進程和輕量級進程的區別。

什麼是上下文切換？

上下文切換指的是操作系統停止當前運行進程（從運行狀態改變成其它狀態）並且調度其它進程（就緒態轉變成運行狀態）。操作系統必須在切換之前存儲許多部分的進程上下文，必須能夠在之後恢復他們，所以進程不能顯示它曾經被暫停過，同時切換上下文這個過程必須快速，因爲上下文切換操作是非常頻繁的。那上下文指的是什麼呢？指的是任務所有共享資源的工作現場，每一個共享資源都有一個工作現場，包括用於處理函數調用、局部變量分配以及工作現場保護的棧頂指針，和用於指令執行等功能的各種寄存器。

注意

這裏所說的進程切換導致上下文切換其實不太準確，準確的說應該是任務的切換導致上下文切換，這裏的任務可以是進程也可以是線程，準確的說線程纔是 CPU 調度的基本單位，但是因爲各個資料都這麼解釋上下文切換，所以上面也暫時這麼介紹，只要讀者心裏有這個概念就好。

進程間通信有幾種方式？

由於各個進程不共享相同的地址空間，任何一個進程的全局變量在另一個進程中都不可見，所以如果想要在進程之間傳遞數據就需要通過內核，在內核中開闢出一塊區域，該區域對多個進程都可見，即可用於進程間通信。有讀者可能有疑問了，文件方式也是進程間通信啊，也要在內核開闢區域嗎？這裏說的內核區域其實是一段緩衝區，文件方式傳輸數據也有內核緩衝區的參與（零拷貝除外）。

如何開闢這種公共區域來進行進程間通信呢？

匿名管道

匿名管道就是 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

信號量和信號有什麼關係？

沒有任何關係，完全是不同的東西。

信號量與互斥量有什麼區別？

互斥量用於互斥，信號量用於同步，互斥指的是某一資源同一時間只允許一個訪問者訪問，但無法限制訪問順序，訪問是無序的，而同步在互斥的基礎上可以控制訪問者對資源的順序。

套接字：就是網絡傳輸，不用多說，網絡通信都可以多機通信呢，更不用說進程間通信啦，你能看到的文章也是套接字的功勞。

文件：顯而易見，多個進程可以操作同一個文件，所以也可以通過文件來進行進程間通信。

關於進程和線程的知識點介紹就到這裏，相信你弄懂這 19 個問題，面試不用愁！

參考資料

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 站哈工大操作系統教學視頻》

推薦關注「Linux 愛好者」，提升 Linux 技能

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/DZYva_tJk5MvpFwU-vkDMA

猜你喜歡