1.系統啟動流程。

uboot -> kernel -> 根文件系統。

uboot第一階段屬于匯編階段：

定義入口（start.S）：uboot中因為有匯編階段參與，因此不能直接找main.c。

設置異常向量：當硬件發生故障的時候CPU會強制PC指針指向對應的異常入口執行代碼。

設置CPU為SVC模式（設置CPU速度、時鐘頻率和中斷控制寄存器）。

初始化內存控制器（MMU），實現虛擬地址到物理地址的映射。

跳轉到lowlevel_init函數，關看門狗，供電鎖存，時鐘初始化。

初始化堆棧，DDR。

uboot第二階段屬于C語言階段：

uboot的第二階段就是要初始化剩下的還沒被初始化的硬件。主要是SoC外部硬件（譬如iNand、網卡芯片····）、uboot本身的一些東西（uboot的命令、環境變量等····）。

調用一系列的初始化函數：init_sequence里的init函數是一個函數指針數組，數組中存儲了很多個函數指針，會去調用其他初始化函數。

cpu_init(CPU內部的初始化)，board_init（x210開發板相關的初始化），interrupt_init（初始化定時器），env_init（環境變量有關的初始化），

init_baudrate（初始化串口通信的波特率），serial_init（初始化串口），display_banner（用來串口輸出顯示uboot的信息）。

uboot啟動內核：

啟動內核第一步：加載內核到DDR中，boot只需要從SD卡的kernel分區去讀取內核鏡像到DDR中即可。

啟動內核第二步：校驗內核格式（zImage格式，uImage格式）。

啟動內核第三步：內核傳參。

內核啟動過程：

內核啟動的匯編階段：

__lookup_processor_type：讀取出硬件的CPU ID號，__lookup_machine_type：本函數校驗的是機器碼，

__vet_atags：用來校驗uboot通過tag給內核傳的參數。

內核啟動C語言階段：

lockdep_init：鎖定依賴，是一個內核調試模塊，處理內核自旋鎖死鎖問題相關的。

boot_init_stack_canary：用來防止棧溢出。

cgroup_init_early：control group，內核提供的一種來處理進程組的技術。

local_irq_disable：屏蔽當前CPU上的所有中斷。

lock_kernel：獲得大內核鎖，該鎖可以用來鎖定整個內核。

page_address_init：函數初始化高端內存頁表池的鏈表。

打印內核版本信息。

最后會執行init進程，init進程剛開始運行的時候是內核態，然后他自己運行了一個用戶態下面的程序后把自己強行轉成了用戶態。

init進程會去掛載根文件系統，打開控制臺，訪問一個設備，就要去打開這個設備對應的文件描述符。譬如/dev/fb0這個設備文件就代表LCD顯示器設備。

根文件系統：

根文件系統是特殊用途的文件系統,文件系統是一些代碼，是一套軟件，這套軟件的功能就是對存儲設備的扇區進行管理，將這些扇區的訪問變成了對目錄和文件名的訪問.

2.什么是操作系統

操作系統是運行在計算機上最重要的一種軟件，它管理計算機的資源和進程以及所有的硬件和軟件。它為計算機硬件和軟件提供了一種中間層，使應用軟件和硬件進行分離。

3.操作系統的主要功能

進程管理: 進程管理的主要作用就是任務調度，在單核處理器下，操作系統會為每個進程分配一個任務。

內存管理：內存管理主要是操作系統負責管理內存的分配、回收。

設備管理：根據確定的設備分配原則對設備進行分配，使設備與主機能夠并行工作。

文件管理：有效地管理文件的存儲空間，合理地組織和管理文件系統。

提供用戶接口：操作系統提供了訪問應用程序和硬件的接口。

4.操作系統的主要目的

• 管理計算機資源，這些資源包括 CPU、內存、磁盤驅動器、打印機等。
• 提供一種圖形界面，就像我們前面描述的那樣，它提供了用戶和計算機之間的橋梁。
• 為其他軟件提供服務，操作系統與軟件進行交互，以便為其分配運行所需的任何必要資源。

5.什么是進程，什么是線程？

進程是系統中正在運行的一個程序，程序一旦運行就是進程，進程可以看成程序執行的一個實例。

線程是CPU獨立運行和獨立調度的基本單位，一個進程可以擁有多個線程，線程是進程的一個實體，是進程的一條執行路徑。

6.進程和線程之間的區別是什么

因為進程擁有獨立的堆棧空間和數據段，所以每當啟動一個新的進程必須分配給它獨立的地址空間，系統開銷比較大。

而線程不一樣，線程擁有獨立的堆棧空間，但是共享數據段，它們彼此之間使用相同的地址空間，共享大部分數據，比進程更節儉，開銷比較小，切換速度也比進

程快，效率高。

通信機制上面，正因為進程之間互不干擾，相互獨立，進程的通信機制相對很復雜，譬如管道，信號，消息隊列，共享內存，套接字等通信機制，而線程由于

共享數據段所以通信機制很方便。

7.多進程和多線程的優缺點

進程優點：每個進程互相獨立，不影響主程序的穩定性，子進程崩潰沒關系；

進程缺點：需要跨進程邊界，如果有大數據量傳送，就不太好，適合小數據量傳送、密集運算多進程調度開銷比較大。

線程優點：能適當提高程序的執行效率，能適當提高資源的利用率。

線程缺點：每個線程與主程序共用地址空間，受限于2GB地址空間；

8.什么時候使用進程，什么時候使用線程

當頻繁創建和銷毀的時候，當然是線程。

當考慮的安全性的問題時候，是進程.

提高cpu利用率，是線程。

9.線程在一定條件下，狀態會發生變化。線程一共有以下5種狀態

新建狀態：新創建了一個線程對象。

就緒狀態：線程只等待獲取CPU的使用權。

運行狀態：就緒狀態的線程獲取了CPU使用權。

阻塞狀態：阻塞狀態是線程因為某種原因放棄CPU使用權，暫時停止運行。

死亡狀態：線程執行完了或者因遇到error或exception退出了run()方法，該線程結束生命周期。

10.孤兒進程，僵尸進程和守護進程

孤兒進程：指的是在其父進程執行完成或被終止 后仍繼續運行的一類進程。

僵尸進程：如果子進程退出，而父進程并沒有調用 wait() 或 waitpid()去回收的一類進程。

守護進程：是運行在后臺的一種特殊進程。守護進程一般在系統啟動時開始運行，除非強行終止，否則直到系統關機都保持運行。

11.進程之間通信的途徑有哪些？

無名管道( pipe )：管道是一種半雙工的通信方式，數據只能單向流動，而且只能在具有親緣關系的進程間使用。

有名管道 (named pipe) ：有名管道也是半雙工的通信方式，但是它允許無親緣關系進程間的通信。

高級管道(popen)：將另一個程序當做一個新的進程在當前程序進程中啟動，則它算是當前程序的子進程，這種方式我們成為高級管道方式。

消息隊列( message queue ) ：消息隊列是由消息的鏈表，存放在內核中并由消息隊列標識符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式字節流以及緩沖區大小受限等缺點。

共享內存( shared memory ) ：共享內存就是映射一段能被其他進程所訪問的內存，這段共享內存由一個進程創建，但多個進程都可以訪問。

套接字( socket ) ：套解口也是一種進程間通信機制，與其他通信機制不同的是，它可用于不同機器間的進程通信。

12.進程上下文

進程上文：其是指進程由用戶態切換到內核態是需要保存用戶態時cpu寄存器中的值，進程狀態以及堆棧上的內容，即保存當前進程的進程上下文，

以便再次執行該進程時，能夠恢復切換時的狀態，繼續執行。

進程下文：其是指切換到內核態后執行的程序，即進程運行在內核空間的部分。

13.LINUX中的虛擬地址空間

防止不同進程同一時刻在物理內存中運行而對物理空間的爭奪采用虛擬地址空間。虛擬內存使得不同進程運行過程中，

每個進程只把自己目前需要的虛擬內存空間映射存儲到物理空間中。

實際上，每個進程創建時，內核只為進程創建虛擬內存的布局，并不立即把虛擬內存和磁盤文件

之間的映射拷貝到物理內存中，等到運行時才會來拷貝數據。
?

14.linux怎么進行內存管理？

對內存的分配和管理，也就是平時應用層malloc和內核層vmalloc、kmalloc之類的內存申請的管理

虛擬內存和物理內存之間的轉換

15.驅動中操作物理絕對地址為什么要先ioremap?

因為在內核中操作的都是虛擬地址，內核訪問不到物理地址，只能通過ioremap映射為虛擬地址，內核才能訪問此內存空間

16.操作系統為什么要分內核態和用戶態

為了安全，在CPU的一些指令中，有的指令如果用錯，就會導致整個系統崩壞，分了內核態和

用戶態之后，當用戶需要操作這些指令的時候，內核為其提供了API，可以通過系統調用陷入

內核，讓內核去執行這些操作。

17.死鎖產生的原因

死鎖產生的原因大致有兩個：資源競爭和程序執行順序不當

18.死鎖產生的必要條件

互斥條件：每個資源都被分配給了一個進程或者資源是可用的。

保持和等待條件：已經獲取資源的進程被認為能夠獲取新的資源。

不可搶占條件：分配給一個進程的資源不能強制的從其他進程搶占資源，它只能由占有它的進程顯示釋放。

循環等待：死鎖發生時，系統中一定有兩個或者兩個以上的進程組成一個循環，循環中的每個進程都在等待下一個進程釋放的資源。

19.insmod 一個驅動模塊，會執行模塊中的哪個函數？rmmod呢？這兩個函數在設計上要注意哪些？遇到過卸載驅動出現異常沒？是什么問題引起的？

insmod調用init函數，rmmod調用exit函數。設計時需要嚴格記住相關內存的操作后必須在exit中進行釋放，

避免內存泄漏。如存儲，ioremap，定時器，工作隊列等等。卸載失敗原因是因為有進程正在使用該模塊，這跟我們在windows下拔出正在使用的U盤類似。

20.linux引入模塊的好處。

該機制有助于縮短模塊的開發周期。

21.copy_to_user()和copy_from_user()主要用于實現什么功能？一般用于file_operations結構的哪些函數里面？

由于內核空間和用戶空間是不能互相訪問的，如果需要訪問就必須借助內核函數進行數據讀寫。

copy_to_user()：完成內核空間到用戶空間的復制。

copy_from_user()：是完成用戶空間到內核空間的復制。

一般用于file_operations結構里的read,write,ioctl等內存數據交換作用的函數。當然，如果ioctl沒有用到內存數據復制，那么就不會用到這兩個函數。
?

22.內核函數mmap的實現原理，機制？

mmap函數實現把一個文件映射到一個內存區域，從而我們可以像讀寫內存一樣讀寫文件，他比單純調用read/write也要快上許多。

在某些時候我們可以把內存的內容拷貝到一個文件中實現內存備份，當然，也可以把文件的內容映射到內存來恢復某些服務。

另外，mmap實現共享內存也是其主要應用之一，mmap系統調用使得進程之間通過映射同一個普通文件實現共享內存。
?

23.用戶空間與內核通信方式有哪些？

系統調用。用戶空間進程通過系統調用進入內核空間，訪問指定的內核空間數據；

)驅動程序。用戶空間進程可以使用封裝后的系統調用接口訪問驅動設備節點，以和運行在內核空間的驅動程序通信；

共享內存mmap。在代碼中調用接口，實現內核空間與用戶空間的地址映射，在實時性要求很高的項目中為首選，省去拷貝數據的時間等資源，但缺點是不好控制；

copy_to_user()、copy_from_user()，是在驅動程序中調用接口，實現用戶空間與內核空間的數據拷貝操作，應用于實時性要求不高的項目中。
?

24.Linux驅動程序的功能是什么？

設備驅動連接操作系統和硬件。設備驅動程序是一種可以使計算機與設備進行通信的特殊程序，可以說相當于硬件的接口。操作系統只有通過這個接口，

才能控制硬件設備的工作。安裝在操作系統中的驅動程序可以完成設備的初始化和釋放，進行外部數據和操作系統的通信和數據交互，控制硬件的行為，

并檢查設備可能出現的故障并報錯。
?

25.Linux驅動程序的分類有哪些？

Linux將硬件設備分為3大類，分別是字符設備、塊設備和網絡設備。字符設備是指那些能一個字節一個字節讀取數據的設備，如鍵盤鼠標等，

常見的SPI/I2C/UART默認也是字符設備。塊設備與字符設備類似，一般是像磁盤一樣的設備。網絡設備主要負責主機之間的數據交換。

與字符設備和塊設備完全不同，網絡設備主要是面向數據包的接收和發送而設計的。
?

26.linux的鎖機制？

互斥鎖：mutex，保證在任何時刻，都只有一個線程訪問該資源，當獲取鎖操作失敗時，線程進入阻塞，等待鎖釋放。

讀寫鎖：rwlock，分為讀鎖和寫鎖，處于讀操作時，可以運行多個線程同時讀。但寫時同一時刻只能有一個線程獲得寫鎖。

自旋鎖：spinlock，在任何時刻只能有一個線程訪問資源。但獲取鎖操作失敗時，不會進入睡眠，而是原地自旋，直到鎖被釋放。

? ? ? ? ? ?這樣節省了線程從睡眠到被喚醒的時間消耗，提高效率。

條件鎖：就是所謂的條件變量，某一個線程因為某個條件未滿足時可以使用條件變量使該程序處于阻塞狀態。一旦條件滿足了，即可喚醒該線程(常和互斥鎖配合使用)。

27.設備驅動程序中如何注冊一個字符設備？分別解釋一下它的幾個參數的含義。

注冊一個字符設備驅動有兩種方法：

?1）?void cdev_init(struct cdev *cdev, struct file_operations *fops)

該注冊函數可以將cdev結構嵌入到自己的設備特定的結構中。cdev是一個指向結構體cdev的指針，而fops是指向一個類似于file_operations結構（可以是file_operations結構，但不限于該結構）的指針.

2）?int register_chrdev(unsigned int major, const char *namem , struct file)operations *fopen);

? ? ? ? 該注冊函數是早期的注冊函數，major是設備的主設備號，name是驅動程序的名稱，而fops是默認的file_operations結構（這 ? ? ? 是只限于file_operations結構）。對于register_chrdev的調用將為給定的主設備號注冊0－255作為次設備號，并為每個 ?設備建 ? ? 立一個對應的默認cdev結構。

28.insmod 一個驅動模塊，會執行模塊中的哪個函數？rmmod呢？這兩個函數在設計上要注意哪些？遇到過卸載驅動出現異常沒？是什么問題引起的？

?insmod調用init函數，rmmod調用exit函數。這兩個函數在設計時要注意什么？卸載模塊時曾出現卸載失敗的情形，原因是存在進程正在使用模塊，檢查代碼后發現產生了死鎖的問題。

? ? ??要注意在init函數中申請的資源在exit函數中要釋放，包括存儲，ioremap，定時器，工作隊列等等。也就是一個模塊注冊進內核，退出內核時要清理所帶來的影響，帶走一切不留下一點痕跡。

01什么是進程？

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

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

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

02 進程和程序有什么聯系？

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

• 程序是產生進程的基礎
• 程序的每次運行產生不同的進程
• 進程是程序功能的體現
• 通過多次執行，一個程序可對應多個進程；通過調用關系，一個進程可包括多個程序

03 進程和程序有什么區別？

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

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

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

04 進程有什么特點？

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

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

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

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

05 進程如何創建？

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

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

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

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

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

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

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

06 進程為何終止？

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

【文章福利】需要C/C++ Linux服務器架構師學習資料加群812855908（資料包括C/C++，Linux，golang技術，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg等）

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

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

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

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

進程控制信息：

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

09?進程如何進行生命周期管理？

進程創建：

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

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

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

進程等待：

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

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

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

進程喚醒：

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

• 被阻塞進程需要的資源可被滿足
• 被阻塞進程等待的事件到達
• 將該進程的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可用，那同一時刻只會有一個進程處于運行狀態，操作系統必須要選擇下一個要運行的是哪個進程，在操作系統中，完成選擇工作的這部分稱為調度程序，該程序使用的算法稱作調度算法。

什么時候進行調度？

1. 系統調用創建一個新進程后，需要決定是運行父進程還是運行子進程
2. 一個進程退出時需要做出調度決策，需要決定下一個運行的是哪個進程
3. 當一個進程阻塞在I/O和信號量或者由于其它原因阻塞時，必須選擇另一個進程運行
4. 當一個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 什么時候用進程、線程？

1. 進程是資源分配單位，線程是CPU調度單位；
2. 進程擁有一個完整的資源平臺，而線程只獨享必不可少的資源，如寄存器和棧；
3. 線程同樣具有就緒阻塞和執行三種基本狀態，同樣具有狀態之間的轉換關系；
4. 線程能減少并發執行的時間和空間開銷：

• 線程的創建時間比進程短
• 線程的終止時間比進程短
• 同一進程內的線程切換時間比進程短
• 由于同一進程的各線程間共享內存和文件資源，可直接進行不通過內核的通信

結論：可以在強調性能時候使用線程，如果追求更好的容錯性可以考慮使用多進程，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 20typedef 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個問題，面試不用愁！

?

總結

以上是生活随笔為你收集整理的Linux操作系统常见问题汇总的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。