這里是仍在筆耕不輟的程序喵大人耗時半個月完成的精心力作：

0 1 什么是進程？

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

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

在操作系統中可以有多個進程在運行，可對于CPU來說，同一時刻，一個CPU只能運行一個進程，但在某一時間段內，CPU將這一時間段拆分成更短的時間片，CPU不停的在各個進程間游走，這就給人一種并行的錯覺，像CPU可以同時運行多個進程一樣，這就是偽并行。 0 2 進程和程序有什么聯系？

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

程序是產生進程的基礎

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

進程是程序功能的體現

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

0 3 進程和程序有什么區別？

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

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

進程和程序的組成不同：進程的組成包括程序、數據和進程控制塊（進程狀態信息）。 0 4 進程有什么特點？

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

并發性：可以被獨立的調度并占用處理機并發運行

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

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

0 5 進程如何創建？

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

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

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

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

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

歸根到底：在UNIX系統中，只有fork系統調用才可以創建新進程，使用方式如下：

#include #include int main() { pid_t id = fork(); if (id < 0) { perror("fork "); } else if (id == 0) { // 子進程 printf("子進程 "); } else { // 父進程 printf("父進程 "); } return 0;}

進程創建之后，父子進程都有各自不同的地址空間，其中一個進程在其地址空間的修改對另一個進程不可見。子進程的初始化空間是父進程的一個副本，這里涉及兩個不同地址空間，不可寫的內存區是共享的，某些UNIX的實現使程序正文在兩者間共享，因為它是不可修改的。

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

0 6 進程為何終止？

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

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

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

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

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

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

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

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

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

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

中斷發生后操作系統最底層做了什么呢？

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

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

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

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

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

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

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

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

0 8 進程控制塊中存儲了什么信息？

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

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

用戶可見寄存器：用戶程序可以使用的數據，地址等寄存器

控制和狀態寄存器：程序計數器，程序狀態字

棧指針：過程調用、系統調用、中斷處理和返回時需要用到它

進程控制信息：

調度和狀態信息：用于操作系統調度進程使用

進程間通信信息：為支持進程間與通信相關的各種標識、信號、信件等，這些信息存在接收方的進程控制塊中

存儲管理信息：包含有指向本進程映像存儲空間的數據結構

進程所用資源：說明由進程打開使用的系統資源，如打開的文件等

有關數據結構連接信息：進程可以連接到一個進程隊列中，或連接到相關的其他進程的PCB

0 9 進程如何進行生命周期管理？

進程創建：

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

系統初始化

用戶請求創建一個新進程

一個正在運行的進程執行創建進程的系統調用

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

進程等待：

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

請求并等待系統服務，無法馬上完成

啟動某種操作，無法馬上完成

需要的數據沒有到達。

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

進程喚醒：

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

被阻塞進程需要的資源可被滿足

被阻塞進程等待的事件到達

將該進程的PCB插入到就緒隊列

進程結束：

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

自愿型正常退出

自愿型錯誤退出

強制型致命錯誤退出

強制型被其它進程殺死退出

10 進程都有什么狀態？

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

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

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

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

進程狀態變化圖如下：

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

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

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

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

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

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

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

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

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

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

阻塞掛起狀態：進程在外存并等待某事件的出現；

就緒掛起狀態：進程在外存，但只要進入內存即可運行。

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

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

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

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

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

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

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

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

阻塞掛起到阻塞：當一個進程釋放足夠內存時，系統會把一個高優先級阻塞掛起進程轉換為阻塞進程。 12 什么是進程調度？操作系統對于進程調度都有什么策略？

當系統中有多個進程同時競爭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::sleep_for(std::seconds(20)); return 0;}想了解更多關于C++線程相關的知識點可以看： ?

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

17 線程是如何實現的？

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

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

用戶線程有如下優點：

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

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

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

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

但用戶線程也有缺點：

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

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

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

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

特點：

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

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

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

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

tips

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

注意

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

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

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

18 什么是上下文切換？

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

注意

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

19 進程間通信有幾種方式？

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

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

匿名管道

匿名管道就是pipe，pipe只能在父子進程間通信，而且數據只能單向流動（半雙工通信）。

使用方式：

1）父進程創建管道，會得到兩個文件描述符，分別指向管道的兩端；

2）父進程創建子進程，從而子進程也有兩個文件描述符指向同一管道；

3）父進程可寫數據到管道，子進程就可從管道中讀出數據，從而實現進程間通信，下面的示例代碼中通過pipe實現了每秒鐘父進程向子進程都發送消息的功能。

#include #include #include int main() { int _pipe[2]; int ret = pipe(_pipe); if (ret < 0) { perror("pipe "); } pid_t id = fork(); if (id < 0) { perror("fork "); } else if (id == 0) { // 子進程 close(_pipe[1]); int j = 0; char _mesg[100]; while (j < 100) { memset(_mesg, '', sizeof(_mesg)); read(_pipe[0], _mesg, sizeof(_mesg)); printf("%s ", _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 #include #include #include #include #include #include #include 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 "; 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 "; } cout << "Receive ok ";} void Send() { MsgWrapper data; long int msgtype = 2; int msgid = msgget((key_t)1024, 0666 | IPC_CREAT); if (msgid == -1) { cout << "msgget error "; 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 "; return; } std::sleep_for(std::seconds(1)); } memcpy(data.text, "1234567", 7); if (msgsnd(msgid, (void *)&data, BUFFER_SIZ, 0) == -1) { cout << "msgsnd error "; return; }} int main() { std::thread r(Receive); r.detach(); std::thread s(Send); s.detach(); std::sleep_for(std::seconds(20)); return 0;} 輸出：root@iZuf64idor3ej648ciairaZ:~# ./a.outread data aread data bread data cread data dread data eread data fread data gread data hread data iread data jread data 1234567Receive 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

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

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

文件：顯而易見，多個進程可以操作同一個文件，所以也可以通過文件來進行進程間通信。 關于進程和線程的知識點介紹就到這里，程序喵為了寫本文花費了半月以上時間，相信你弄懂這19個問題，面試不用愁！

原文標題：進程和線程常見的19個問題

文章出處：【微信公眾號：strongerHuang】歡迎添加關注！文章轉載請注明出處。

責任編輯：haq