在Linux 的世界里，進程就像是一個個活躍的小生命，它們在系統(tǒng)的舞臺上各司其職，共同演繹著復(fù)雜而精彩的計算交響樂。簡單來說，進程是程序的一次執(zhí)行實例。當(dāng)你在 Linux 系統(tǒng)中運行一個程序，比如用命令行啟動一個 Python 腳本，系統(tǒng)就會創(chuàng)建一個進程來執(zhí)行這個腳本。程序本身只是存儲在磁盤上的一組靜態(tài)指令和數(shù)據(jù)，而進程則是這些指令和數(shù)據(jù)在內(nèi)存中的動態(tài)運行過程。進程具有一些關(guān)鍵屬性，這些屬性就像是它們的 “身份標簽” 和 “行為準則”。

比如，每個進程都有一個唯一的進程標識符（PID），這就好比每個人的身份證號碼，系統(tǒng)通過 PID 來識別和管理不同的進程。進程還有自己的狀態(tài)，常見的狀態(tài)包括運行態(tài)（R）、睡眠態(tài)（S）、停止態(tài)（T）和僵尸態(tài)（Z）等 。

• 運行態(tài)表示進程正在 CPU 上執(zhí)行或準備執(zhí)行；
• 睡眠態(tài)則是進程在等待某個事件的完成，比如等待 I/O 操作結(jié)束；
• 停止態(tài)是進程被暫停，通常是因為接收到了特定的信號；

僵尸態(tài)比較特殊，當(dāng)子進程結(jié)束運行但父進程沒有回收其資源時，子進程就會進入僵尸態(tài)。進程的優(yōu)先級也很重要，它決定了進程獲取 CPU 時間的先后順序。優(yōu)先級高的進程會優(yōu)先被調(diào)度執(zhí)行，就像在醫(yī)院里，急診病人會比普通病人優(yōu)先得到救治一樣。在 Linux 系統(tǒng)中，進程的優(yōu)先級可以通過 nice 值來調(diào)整，nice 值的范圍是 -20 到 19，值越小優(yōu)先級越高。不過，普通用戶只能在一定范圍內(nèi)調(diào)整自己進程的 nice 值，而 root 用戶則擁有更大的權(quán)限。

一、Linux進程概念

從理論角度看，是對正在運行的程序過程的抽象；

從實現(xiàn)角度看，是一種數(shù)據(jù)結(jié)構(gòu)，目的在于清晰地刻畫動態(tài)系統(tǒng)的內(nèi)在規(guī)律，有效管理和調(diào)度進入計算機系統(tǒng)主存儲器運行的程序。

1. 什么是進程？

• 狹義定義：進程就是一段程序的執(zhí)行過程。
• 廣義定義：進程是一個具有一定獨立功能的程序關(guān)于某個數(shù)據(jù)集合的一次運行活動。它是操作系統(tǒng)動態(tài)執(zhí)行的基本單元，在傳統(tǒng)的操作系統(tǒng)中，進程既是基本的分配單元，也是基本的執(zhí)行單元。
• 進程有怎么樣的特征？
• 動態(tài)性：進程的實質(zhì)是程序在多道程序系統(tǒng)中的一次執(zhí)行過程，進程是動態(tài)產(chǎn)生，動態(tài)消亡的。
• 并發(fā)性：任何進程都可以同其他進程一起并發(fā)執(zhí)行
• 獨立性：進程是一個能獨立運行的基本單位，同時也是系統(tǒng)分配資源和調(diào)度的獨立單位；
• 異步性：由于進程間的相互制約，使進程具有執(zhí)行的間斷性，即進程按各自獨立的、不可預(yù)知的速度向前推 進
• 結(jié)構(gòu)特征：進程由程序、數(shù)據(jù)和進程控制塊三部分組成;
• 多個不同的進程可以包含相同的程序：一個程序在不同的數(shù)據(jù)集里就構(gòu)成不同的進程，能得到不同的結(jié)果；但是執(zhí)行過程中，程序不能發(fā)生改變。

2. Linux進程結(jié)構(gòu)？

Linux進程結(jié)構(gòu)：可由三部分組成：代碼段、數(shù)據(jù)段、堆棧段。也就是程序、數(shù)據(jù)、進程控制塊PCB（Process Control Block）組成。進程控制塊是進程存在的惟一標識，系統(tǒng)通過PCB的存在而感知進程的存在。

系統(tǒng)通過PCB對進程進行管理和調(diào)度。PCB包括創(chuàng)建進程、執(zhí)行程序、退出進程以及改變進程的優(yōu)先級等。而進程中的PCB用一個名為task_struct的結(jié)構(gòu)體來表示，定義在include/linux/sched.h中，每當(dāng)創(chuàng)建一新進程時，便在內(nèi)存中申請一個空的task_struct結(jié)構(gòu)，填入所需信息，同時，指向該結(jié)構(gòu)的指針也被加入到task數(shù)組中，所有進程控制塊都存儲在task[]數(shù)組中。

進程的三種基本狀態(tài)：

• 就緒狀態(tài)：進程已獲得除處理器外的所需資源，等待分配處理器資源；只要分配了處理器進程就可執(zhí)行。就緒進程可以按多個優(yōu)先級來劃分隊列。例如，當(dāng)一個進程由于時間片用完而進入就緒狀態(tài)時，排入低優(yōu)先級隊列；當(dāng)進程由I/O操作完成而進入就緒狀態(tài)時，排入高優(yōu)先級隊列。
• 運行狀態(tài)：進程占用處理器資源；處于此狀態(tài)的進程的數(shù)目小于等于處理器的數(shù)目。在沒有其他進程可以 執(zhí)行時(如所有進程都在阻塞狀態(tài))，通常會自動執(zhí)行系統(tǒng)的空閑進程。
• 阻塞狀態(tài)：由于進程等待某種條件（如I/O操作或進程同步），在條件滿足之前無法繼續(xù)執(zhí)行。該事件發(fā)生 前即使把處理機分配給該進程，也無法運行。

3. 進程和程序的區(qū)別？

• 程序是指令和數(shù)據(jù)的有序集合，是一個靜態(tài)的概念。而進程是程序在處理機上的一次執(zhí)行過程，它是一個 動態(tài)的概念。
• 程序可以作為一種軟件資料長期存在，而進程是有一定生命期的。程序是永久的，進程是暫時的。
• 進程是由進程控制塊、程序段、數(shù)據(jù)段三部分組成;
• 進程具有創(chuàng)建其他進程的功能，而程序沒有。
• 同一程序同時運行于若干個數(shù)據(jù)集合上，它將屬于若干個不同的進程，也就是說同一程序可以對應(yīng)多個進 程。
• 在傳統(tǒng)的操作系統(tǒng)中，程序并不能獨立運行，作為資源分配和獨立運行的基本單元都是進程。

二、進程的查看與監(jiān)控

在 Linux 系統(tǒng)中，了解進程的運行狀態(tài)是系統(tǒng)管理和調(diào)試的重要環(huán)節(jié)。就像一位交通警察需要時刻了解道路上車輛的行駛情況一樣，系統(tǒng)管理員和開發(fā)者需要通過各種工具來查看和監(jiān)控進程。下面我們就來介紹幾個常用的命令。

1. ps命令

ps 命令就像是進程世界的 “普查員”，它可以讓我們查看系統(tǒng)中正在運行的進程的詳細信息。通過不同的選項組合，ps 命令能夠展現(xiàn)出進程的豐富細節(jié)。

比如，使用ps -aux命令，它會列出系統(tǒng)中所有用戶的進程信息。這里的a表示顯示所有用戶的進程（包括其他用戶的進程），u是以用戶友好的格式顯示進程信息（包括用戶名、CPU 和內(nèi)存使用率等詳細信息），x表示顯示沒有控制終端的進程（通常是后臺進程） 。在我的 Linux 服務(wù)器上執(zhí)行這個命令，得到的部分輸出如下：

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1  16120  3340?        Ss   08:21   0:01 /sbin/init splash
root         2  0.0  0.0      0     0?        S    08:21   0:00 [kthreadd]
root         3  0.0  0.0      0     0?        S    08:21   0:00 [ksoftirqd/0]

在這些輸出信息中，USER表示進程所屬的用戶；PID是進程的唯一標識符；%CPU顯示進程使用的 CPU 百分比；%MEM是進程使用的內(nèi)存百分比；VSZ代表進程使用的虛擬內(nèi)存大小（單位：KB）；RSS是進程使用的物理內(nèi)存大?。▎挝唬篕B）；TTY表示進程所連接的終端設(shè)備；STAT是進程狀態(tài)，常見的如S表示睡眠態(tài)，R表示運行態(tài)等；START是進程啟動時間；TIME是進程占用 CPU 的累計時間；COMMAND則是啟動進程的命令名稱和參數(shù)。

而ps -ef命令同樣用于顯示所有進程的詳細信息，這里的-e表示顯示所有進程，包括其他用戶的進程，-f是以完整格式顯示進程信息 。它的輸出格式與ps -aux略有不同，但包含的核心信息是一致的。例如：

UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 08:21?        00:00:01 /sbin/init splash
root         2     0  0 08:21?        00:00:00 [kthreadd]
root         3     2  0 08:21?        00:00:00 [ksoftirqd/0]

其中，UID是進程所有者的用戶 ID，PPID是父進程 ID，C表示 CPU 使用率，STIME是進程啟動時間，TTY是進程關(guān)聯(lián)的終端設(shè)備，TIME是進程占用的 CPU 時間，CMD是啟動進程的命令名稱和參數(shù)。通過這些信息，我們可以清晰地了解每個進程的基本情況。

2. top命令

top 命令則像是一個 “實時監(jiān)控器”，它為我們提供了系統(tǒng)進程的動態(tài)實時視圖，讓我們可以實時了解系統(tǒng)中各個進程的資源占用狀況，就像在觀看一場實時的比賽直播一樣，隨時掌握進程的 “戰(zhàn)況”。

當(dāng)我們在命令行輸入top命令后，會看到一個動態(tài)更新的界面，它每隔一段時間（默認 3 秒）就會自動刷新，展示最新的進程狀態(tài)。界面的頂部顯示了系統(tǒng)的一些關(guān)鍵信息，如系統(tǒng)的運行時間、當(dāng)前登錄用戶數(shù)、系統(tǒng)負載（load average）等 。接下來是進程統(tǒng)計信息，包括總進程數(shù)、正在運行的進程數(shù)、睡眠的進程數(shù)、停止的進程數(shù)和僵尸進程數(shù)等。再下面是 CPU 使用情況的詳細統(tǒng)計，包括用戶空間占用 CPU 百分比、內(nèi)核空間占用 CPU 百分比、空閑 CPU 百分比等 。還有內(nèi)存和交換分區(qū)的使用情況統(tǒng)計。

在 top 命令的交互界面中，我們可以通過一些按鍵來進行各種操作。比如，按下P鍵，進程列表會按照 CPU 使用率從高到低進行排序，這樣我們就能快速找到那些 “吃 CPU 大戶” 的進程；按下M鍵，會按照內(nèi)存使用率排序，幫助我們定位占用內(nèi)存較多的進程；按下N鍵，會以 PID 排序 。如果我們想要監(jiān)控特定用戶的進程，可以按下u鍵，然后輸入用戶名，界面就會只顯示該用戶的進程。當(dāng)我們發(fā)現(xiàn)某個進程占用資源過高且不需要它繼續(xù)運行時，可以按下k鍵，然后輸入該進程的 PID，再按下回車鍵，就可以終止該進程（默認發(fā)送的是 15 信號，即正常終止進程，如果進程沒有響應(yīng)，可以再次輸入 9，發(fā)送強制終止信號） 。按下q鍵則可以退出 top 命令界面。

3. pstree命令

pstree 命令就像是一位 “家族譜繪制師”，它以樹狀結(jié)構(gòu)展示進程之間的關(guān)系，讓我們可以一目了然地看到各個進程之間的父子關(guān)系，就像查看一個家族的族譜一樣清晰。

當(dāng)我們執(zhí)行pstree命令時，它會以init進程（在 systemd 系統(tǒng)中通常是systemd進程）為根節(jié)點，展示整個系統(tǒng)的進程樹。例如，在我的系統(tǒng)上執(zhí)行pstree命令，得到的部分輸出如下：

systemd─┬─ModemManager───2*[{ModemManager}]
        ├─NetworkManager─┬─dhclient
        │                ├─dnsmasq───2*[{dnsmasq}]
        │                └─2*[{NetworkManager}]
        ├─agetty
        ├─atd
        ├─auditd───{auditd}
        ├─chronyd

從這個輸出中，我們可以清晰地看到systemd是很多進程的父進程，比如ModemManager、NetworkManager等，而NetworkManager又有自己的子進程，如dhclient、dnsmasq等 。如果我們想要查看某個特定進程 ID 的進程樹，可以使用pstree -p PID的形式，其中PID是具體的進程 ID。例如，pstree -p 1會以init進程（PID 通常為 1）為根節(jié)點，展示其完整的進程樹，并在每個進程名稱旁邊顯示其 PID 。如果我們只想查看某個用戶的所有進程及其關(guān)系，可以使用pstree -u username的形式，其中username是具體的用戶名。

三、進程的控制與管理

1. 進程的啟動與終止

在 Linux 系統(tǒng)中，啟動進程是一項常見的操作。最基本的方式就是在命令行直接輸入命令并回車，此時進程會在前臺運行 。例如，輸入ls命令，系統(tǒng)會立即列出當(dāng)前目錄下的文件和文件夾，在這個過程中，命令行被該進程占用，直到ls命令執(zhí)行完畢，才會返回命令提示符，在此期間我們無法在同一命令行執(zhí)行其他命令。

造成進程產(chǎn)生的主要事件有：

• 系統(tǒng)初始化
• 執(zhí)行進程創(chuàng)立程序
• 用戶請求創(chuàng)立新進程

造成進程消亡的事件：

• 進程運行完成而退出。
• 進程因錯誤而自行退出
• 進程被其他進程所終止
• 進程因異常而被強行終結(jié)

如果我們希望命令在后臺運行，不占用命令行，以便可以同時執(zhí)行其他操作，可以在命令后面加上&符號 。比如，我們想要運行一個長時間的計算任務(wù)，如python long_computation.py &，這樣該 Python 腳本就會在后臺啟動，命令行馬上返回提示符，我們可以繼續(xù)執(zhí)行其他命令 。通過這種方式，多個命令可以并行執(zhí)行，提高了工作效率。需要注意的是，使用&符號將命令放到后臺運行后，該進程的父進程還是當(dāng)前終端 shell 的進程。一旦父進程退出，它會發(fā)送 hangup 信號給所有子進程，子進程收到 hangup 信號以后也會退出。

對于已經(jīng)在前臺執(zhí)行的命令，如果想要將其放到后臺運行，可以先按下Ctrl+Z組合鍵暫停該進程，然后使用bg命令將其放到后臺繼續(xù)運行 。例如，我們在前臺執(zhí)行vim編輯文件時，突然需要執(zhí)行其他命令，就可以按下Ctrl+Z暫停vim進程，然后輸入bg命令將vim放到后臺，此時可以執(zhí)行其他命令。若要將后臺進程恢復(fù)到前臺運行，可以使用fg命令，加上對應(yīng)的作業(yè)編號，作業(yè)編號可以通過jobs命令查看，jobs命令會顯示所有暫停以及后臺執(zhí)行的命令及其編號。

當(dāng)我們不再需要某個進程運行時，就需要終止它。在 Linux 中，常用kill命令和killall命令來終止進程 。kill命令用于終止指定進程 ID（PID）的進程。首先，我們需要通過ps等命令獲取要終止進程的 PID，例如ps -aux | grep process_name，然后使用kill PID來終止該進程。如果進程比較頑固，無法通過正常方式終止，可以使用kill -9 PID來強制終止，-9表示發(fā)送 SIGKILL 信號，這是一種強制終止進程的方式，進程無法忽略該信號，但可能會導(dǎo)致數(shù)據(jù)丟失等問題，所以要謹慎使用 。比如，當(dāng)一個程序出現(xiàn)死鎖或者無響應(yīng)時，我們可以使用kill -9來結(jié)束它。

killall命令則是根據(jù)進程名稱來終止所有匹配該名稱的進程 。它的使用相對簡單，不需要先查找進程 ID，直接使用killall process_name即可。例如，要終止所有的nginx進程，只需輸入killall nginx 。不過，使用killall命令時要特別小心，因為它會終止所有匹配名稱的進程，如果名稱不唯一，可能會誤殺其他有用的進程。

2. 進程優(yōu)先級調(diào)整

進程優(yōu)先級決定了進程在競爭系統(tǒng)資源（如 CPU 時間）時的先后順序。在 Linux 系統(tǒng)中，進程優(yōu)先級的范圍是 -20 到 19，數(shù)值越小優(yōu)先級越高 。例如，一個優(yōu)先級為 -10 的進程會比優(yōu)先級為 5 的進程更優(yōu)先獲得 CPU 時間。

我們可以通過ps -l命令查看進程的優(yōu)先級相關(guān)信息，其中PRI字段表示進程的實際優(yōu)先級，NI字段表示進程的 nice 值 。nice 值不是進程的優(yōu)先級本身，而是用于調(diào)整優(yōu)先級的修正數(shù)據(jù)，進程的實際優(yōu)先級（PRI）會根據(jù) nice 值進行調(diào)整，計算公式為PRI = PRI(old) + nice，通常初始的 PRI 值為 80 。比如，一個進程的 nice 值為 0，那么它的實際優(yōu)先級 PRI 就是 80；如果將其 nice 值調(diào)整為 5，那么新的實際優(yōu)先級 PRI 就變?yōu)?85，優(yōu)先級相對降低。

如果想要改變進程的優(yōu)先級，可以使用nice命令和renice命令 。nice命令主要用于在啟動進程時設(shè)置其優(yōu)先級。例如，我們要以較高的優(yōu)先級啟動一個top命令來實時監(jiān)控系統(tǒng)資源，可以使用nice -n -10 top，這里-n選項后面的 -10 表示設(shè)置的 nice 值，數(shù)值越小優(yōu)先級越高 。這樣啟動的top進程就會比普通啟動的top進程更優(yōu)先獲得 CPU 資源，能更及時地反映系統(tǒng)狀態(tài)。

renice命令則用于修改已經(jīng)在運行的進程的優(yōu)先級 。假設(shè)我們有一個正在運行的進程，其 PID 為 12345，現(xiàn)在想要將它的優(yōu)先級降低，可以使用renice -n 5 12345，這會將該進程的 nice 值設(shè)置為 5，從而調(diào)整其實際優(yōu)先級 。在實際應(yīng)用中，比如當(dāng)我們發(fā)現(xiàn)某個后臺進程占用過多 CPU 資源，影響到其他更重要的進程運行時，就可以使用renice命令降低它的優(yōu)先級，確保系統(tǒng)資源能合理分配給各個進程。

3. 進程間通信

在 Linux 系統(tǒng)中，多個進程常常需要相互協(xié)作、交換信息，這就需要進程間通信（IPC，Inter-Process Communication）機制 。比如，一個網(wǎng)絡(luò)服務(wù)器進程可能需要與多個客戶端進程進行數(shù)據(jù)交互，一個圖形界面程序可能需要與后臺的數(shù)據(jù)處理進程通信來獲取和展示數(shù)據(jù)。下面介紹幾種常見的進程間通信方式。

(1) 管道（Pipe）

管道是一種半雙工的通信方式，數(shù)據(jù)只能單向流動，而且通常只能在具有親緣關(guān)系（如父子進程）的進程間使用 。它在內(nèi)核中維護了一塊內(nèi)存作為緩沖區(qū)，有讀端和寫端 。我們可以使用pipe函數(shù)創(chuàng)建無名管道，父進程創(chuàng)建管道后通過fork子進程，子進程會繼承父進程的管道文件描述符，從而實現(xiàn)父子進程間的通信 。例如，父進程向管道寫端寫入數(shù)據(jù)，子進程從管道讀端讀取數(shù)據(jù)。

管道的讀寫遵循一定規(guī)則，當(dāng)管道的寫端不存在時，讀操作會認為已經(jīng)讀到數(shù)據(jù)末尾，返回的讀出字節(jié)數(shù)為 0；當(dāng)管道的寫端存在時，如果請求讀取的字節(jié)數(shù)目大于管道緩沖區(qū)的大小（PIPE_BUF），則返回管道中現(xiàn)有的數(shù)據(jù)字節(jié)數(shù)，如果請求的字節(jié)數(shù)目不大于 PIPE_BUF，則返回管道中現(xiàn)有數(shù)據(jù)字節(jié)數(shù)（當(dāng)管道中數(shù)據(jù)量小于請求的數(shù)據(jù)量時）或者返回請求的字節(jié)數(shù)（當(dāng)管道中數(shù)據(jù)量不小于請求的數(shù)據(jù)量時） 。向管道中寫入數(shù)據(jù)時，如果管道緩沖區(qū)已滿，寫操作將一直阻塞，直到有數(shù)據(jù)被讀取，緩沖區(qū)有空閑空間 。例如：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.h>

int main(void) {
    char buf[32] = {0};
    pid_t pid;
    int fd[2];

    // 創(chuàng)建無名管道
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid > 0) {
        // 父進程
        close(fd[0]); // 關(guān)閉讀端
        write(fd[1], "hello", 5); // 向?qū)懚藢懭霐?shù)據(jù)
        close(fd[1]); // 關(guān)閉寫端
        wait(NULL); // 等待子進程結(jié)束
    } else {
        // 子進程
        close(fd[1]); // 關(guān)閉寫端
        read(fd[0], buf, 32); // 從讀端讀取數(shù)據(jù)
        printf("buf is %s\n", buf);
        close(fd[0]); // 關(guān)閉讀端
    }

    return 0;
}

在這個例子中，父進程創(chuàng)建管道后，通過fork創(chuàng)建子進程，然后父進程關(guān)閉讀端，向?qū)懚藢懭?“hello”，子進程關(guān)閉寫端，從讀端讀取數(shù)據(jù)并打印。

(2) 命名管道（Named Pipe，F(xiàn)IFO）

命名管道也是半雙工的通信方式，但它允許無親緣關(guān)系的進程間通信 。它的實質(zhì)是內(nèi)核維護的一塊內(nèi)存，表現(xiàn)為一個有名字的文件 。我們可以使用mkfifo函數(shù)創(chuàng)建命名管道，不同進程通過打開同一個命名管道文件來進行通信 。比如，一個進程以寫模式打開命名管道，另一個進程以讀模式打開，就可以實現(xiàn)數(shù)據(jù)的傳輸 。例如，有兩個進程writer.c和reader.c，writer.c負責(zé)向命名管道寫入數(shù)據(jù)，reader.c負責(zé)從命名管道讀取數(shù)據(jù)：

// writer.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    int fd;
    char cont_w[] = "hello sundy";

    // 創(chuàng)建命名管道
    if (mkfifo("myfifo", 0666) == -1) {
        perror("mkfifo");
        return 1;
    }

    // 以寫模式打開命名管道
    fd = open("myfifo", O_WRONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    write(fd, cont_w, sizeof(cont_w));
    close(fd);

    return 0;
}
// reader.c
/*
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main() {
    int fd;
    char buf[32] = {0};

    // 以讀模式打開命名管道
    fd = open("myfifo", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    read(fd, buf, sizeof(buf));
    printf("buf is %s\n", buf);
    close(fd);

    return 0;
} */

在這個例子中，writer.c創(chuàng)建命名管道 “myfifo” 并寫入數(shù)據(jù)，reader.c打開該命名管道讀取數(shù)據(jù)并打印。

(3) 共享內(nèi)存（Shared Memory）

共享內(nèi)存是一種高效的進程間通信方式，它允許多個進程直接訪問同一塊內(nèi)存區(qū)域 。共享內(nèi)存的實現(xiàn)是通過將內(nèi)存段映射到共享它的進程的地址空間，這樣進程間的數(shù)據(jù)傳送不再需要通過內(nèi)核進行多次數(shù)據(jù)復(fù)制，大大提高了通信效率 。使用共享內(nèi)存時，通常需要配合信號量等機制來實現(xiàn)進程間的同步和互斥，防止多個進程同時訪問共享內(nèi)存時出現(xiàn)數(shù)據(jù)沖突 。例如，一個進程創(chuàng)建共享內(nèi)存段并寫入數(shù)據(jù)，其他進程可以通過映射該共享內(nèi)存段來讀取數(shù)據(jù) 。下面是一個簡單的示例：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE 1024

int main() {
    key_t key;
    int shmid;
    char *shm, *s;

    // 生成一個唯一的鍵值
    key = ftok(".", 'a');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    // 創(chuàng)建共享內(nèi)存段
    shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }

    // 將共享內(nèi)存段映射到進程地址空間
    shm = (char *)shmat(shmid, NULL, 0);
    if (shm == (char *)-1) {
        perror("shmat");
        return 1;
    }

    s = shm;
    // 向共享內(nèi)存寫入數(shù)據(jù)
    for (int i = 0; i < 10; i++) {
        sprintf(s, "This is %d\n", i);
        s += strlen(s);
    }

    // 等待其他進程讀取數(shù)據(jù)
    while (*shm != '*') {
        sleep(1);
    }

    // 取消映射
    if (shmdt(shm) == -1) {
        perror("shmdt");
        return 1;
    }

    // 刪除共享內(nèi)存段
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        return 1;
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE 1024

int main() {
    key_t key;
    int shmid;
    char *shm, *s;

    // 生成相同的鍵值
    key = ftok(".", 'a');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    // 獲取共享內(nèi)存段
    shmid = shmget(key, SHM_SIZE, 0666);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }

    // 將共享內(nèi)存段映射到進程地址空間
    shm = (char *)shmat(shmid, NULL, 0);
    if (shm == (char *)-1) {
        perror("shmat");
        return 1;
    }

    // 從共享內(nèi)存讀取數(shù)據(jù)
    s = shm;
    while (*s != '\0') {
        printf("%s", s);
        s += strlen(s);
    }

    // 標記數(shù)據(jù)已讀取
    *shm = '*';

    // 取消映射
    if (shmdt(shm) == -1) {
        perror("shmdt");
        return 1;
    }

    return 0;
}

在這個示例中，第一個進程創(chuàng)建共享內(nèi)存并寫入數(shù)據(jù)，然后等待第二個進程讀取數(shù)據(jù)并標記，第二個進程獲取共享內(nèi)存并讀取數(shù)據(jù)，讀取完成后標記數(shù)據(jù)已讀取。

(4) 消息隊列（Message Queue）

消息隊列是由消息的鏈表組成，存放在內(nèi)核中并由消息隊列標識符標識 。它克服了信號傳遞信息少、管道只能承載無格式字節(jié)流以及緩沖區(qū)大小受限等缺點 。進程可以向消息隊列發(fā)送消息，也可以從消息隊列接收消息 。消息隊列中的消息具有類型，接收進程可以根據(jù)消息類型有選擇地接收消息 。例如，在一個多進程協(xié)作的系統(tǒng)中，不同的進程可以根據(jù)自己的需求向消息隊列發(fā)送不同類型的消息，其他進程可以根據(jù)自身需要從消息隊列中獲取特定類型的消息進行處理 。下面是一個簡單的消息隊列使用示例：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

#define MSG_SIZE 128

// 消息結(jié)構(gòu)
typedef struct msgbuf {
    long mtype;
    char mtext[MSG_SIZE];
} msgbuf;

int main() {
    key_t key;
    int msgid;
    msgbuf msg;

    // 生成一個唯一的鍵值
    key = ftok(".", 'b');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    // 創(chuàng)建消息隊列
    msgid = msgget(key, IPC_CREAT | 0666);
    if (msgid == -1) {
        perror("msgget");
        return 1;
    }

    // 填充消息
    msg.mtype = 1;
    strcpy(msg.mtext, "Hello, message queue!");

    // 發(fā)送消息
    if (msgsnd(msgid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
        perror("msgsnd");
        return 1;
    }

    printf("Message sent.\n");

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

#define MSG_SIZE 128

// 消息結(jié)構(gòu)
typedef struct msgbuf {
    long mtype;
    char mtext[MSG_SIZE];
} msgbuf;

int main() {
    key_t key;
    int msgid;
    msgbuf msg;

    // 生成相同的鍵值
    key = ftok(".", 'b');
    if (key == -1) {
        perror("ftok");
        return 1;
    }

    // 獲取消息隊列
    msgid = msgget(key, 0666);
    if (msgid == -1) {
        perror("msgget");
        return 1;
    }

    // 接收消息
    if (msgrcv(msgid, &msg, MSG_SIZE, 1, 0) == -1) {
        perror("msgrcv");
        return 1;
    }

    printf("Received message: %s\n", msg.mtext);

    return 0;
}

在這個示例中，第一個進程創(chuàng)建消息隊列并發(fā)送一條類型

四、特殊進程剖析

1. 守護進程

守護進程，也被稱為精靈進程，是 Linux 系統(tǒng)中一類特殊的進程，它們?nèi)缤刈o系統(tǒng)的 “幕后英雄”，在后臺持續(xù)運行，執(zhí)行著各種重要的系統(tǒng)任務(wù) 。與普通進程不同，守護進程脫離于終端運行，這意味著它們不受終端的控制，也不會在終端上顯示輸出信息，即使終端關(guān)閉，守護進程依然能夠繼續(xù)運行 。就像一位忠誠的守衛(wèi)，無論周圍環(huán)境如何變化，始終堅守崗位。

守護進程具有一些顯著的特點。首先，它們在后臺長期運行，通常在系統(tǒng)啟動時就被自動啟動，并且一直持續(xù)運行到系統(tǒng)關(guān)閉 。比如，系統(tǒng)日志守護進程syslogd，它負責(zé)收集和記錄系統(tǒng)中的各種日志信息，從系統(tǒng)啟動的那一刻起，它就開始默默地工作，記錄著系統(tǒng)運行過程中的點點滴滴，為系統(tǒng)管理員提供了重要的故障排查和系統(tǒng)監(jiān)控依據(jù) 。其次，守護進程沒有控制終端，這使得它們能夠獨立運行，不依賴于用戶的交互操作 。

例如，網(wǎng)絡(luò)守護進程sshd，它允許用戶通過 SSH 協(xié)議遠程登錄到系統(tǒng)，即使沒有用戶在本地終端進行操作，sshd依然在后臺監(jiān)聽網(wǎng)絡(luò)端口，等待用戶的連接請求，保障了遠程管理的便捷性 。另外，守護進程通常以系統(tǒng)權(quán)限運行，這賦予了它們訪問系統(tǒng)關(guān)鍵資源和執(zhí)行重要任務(wù)的能力 。比如，cron守護進程，它負責(zé)執(zhí)行周期性的任務(wù)，如定時備份文件、更新系統(tǒng)軟件等，需要具備足夠的權(quán)限來操作相關(guān)的文件和目錄 。

在 Linux 系統(tǒng)中，有許多常見的守護進程。除了前面提到的syslogd、sshd和cron，還有httpd（Apache Web 服務(wù)器守護進程），它負責(zé)處理 Web 服務(wù)器的請求，使得我們能夠在瀏覽器中訪問網(wǎng)站；mysqld（MySQL 數(shù)據(jù)庫服務(wù)器守護進程），它管理著 MySQL 數(shù)據(jù)庫，為各種應(yīng)用程序提供數(shù)據(jù)存儲和檢索服務(wù) 。這些守護進程在系統(tǒng)中各司其職，共同維持著系統(tǒng)的穩(wěn)定運行 。

對于守護進程的管理，我們可以使用不同的工具和方法 。在基于 Systemd 的系統(tǒng)中，使用systemctl命令來管理守護進程非常方便 。比如，要啟動httpd守護進程，可以使用systemctl start httpd命令；要停止它，使用systemctl stop httpd命令；要查看其狀態(tài)，使用systemctl status httpd命令 。如果希望httpd守護進程在系統(tǒng)啟動時自動啟動，可以使用systemctl enable httpd命令；如果不想讓它自動啟動，則使用systemctl disable httpd命令 。另外，對于一些簡單的守護進程，我們也可以使用nohup命令來啟動，它可以讓進程在后臺運行，并且忽略掛斷信號 。

例如，nohup my_daemon &可以將my_daemon這個守護進程在后臺啟動，輸出信息會被重定向到nohup.out文件中 。還有supervisor，它是一個功能強大的進程管理工具，可以方便地管理和監(jiān)控守護進程 。通過配置supervisor的配置文件，我們可以定義守護進程的啟動命令、自動重啟策略、日志輸出等 。比如，在/etc/supervisor/conf.d/目錄下創(chuàng)建一個守護進程的配置文件，然后使用supervisorctl命令來啟動、停止、重啟守護進程，還可以查看其狀態(tài)和日志 。

2. 僵尸進程與孤兒進程

在 Linux 進程的世界里，僵尸進程和孤兒進程是兩種比較特殊的進程狀態(tài)，它們有著獨特的產(chǎn)生原因和特點。

僵尸進程是指子進程已經(jīng)終止運行，但父進程沒有調(diào)用wait或waitpid函數(shù)來獲取子進程的退出狀態(tài)信息，此時子進程就會變成僵尸進程 。簡單來說，就像孩子已經(jīng)長大離開家（子進程結(jié)束），但家長（父進程）卻沒有去了解孩子的情況，孩子就一直處于一種 “懸而未決” 的狀態(tài) 。

從系統(tǒng)的角度看，僵尸進程雖然已經(jīng)不再占用 CPU 等運行資源，但它的進程描述符仍然保留在系統(tǒng)中，占用著進程表的一個位置 。這就好比一個已經(jīng)畢業(yè)的學(xué)生，雖然不再在學(xué)校上課（不占用運行資源），但學(xué)校的學(xué)籍系統(tǒng)里還保留著他的學(xué)籍信息（占用進程表位置） 。如果系統(tǒng)中存在大量的僵尸進程，會導(dǎo)致進程號資源被大量占用，因為系統(tǒng)所能使用的進程號是有限的，當(dāng)進程號耗盡時，系統(tǒng)將無法創(chuàng)建新的進程，這會對系統(tǒng)的正常運行造成嚴重影響 。

例如，我們來看下面這段 C 代碼：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子進程
        printf("Child process, PID: %d\n", getpid());
        exit(0);
    } else {
        // 父進程
        printf("Parent process, PID: %d\n", getpid());
        while (1) {
            sleep(1);
        }
    }
    return 0;
}

在這段代碼中，父進程創(chuàng)建子進程后，子進程很快退出，但父進程沒有調(diào)用wait或waitpid來處理子進程的退出，此時子進程就會變成僵尸進程 。我們可以通過ps -aux命令查看進程狀態(tài)，會發(fā)現(xiàn)處于僵尸狀態(tài)的子進程，其狀態(tài)字段顯示為Z 。

為了避免僵尸進程的產(chǎn)生，我們可以采取一些措施 。一種方法是在父進程中調(diào)用wait或waitpid函數(shù)來等待子進程的結(jié)束，并獲取其退出狀態(tài)信息 。wait函數(shù)會使父進程阻塞，直到有子進程結(jié)束；waitpid函數(shù)則更加靈活，可以指定等待特定的子進程，并且可以設(shè)置非阻塞模式 。例如：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子進程
        printf("Child process, PID: %d\n", getpid());
        exit(0);
    } else {
        // 父進程
        printf("Parent process, PID: %d\n", getpid());
        int status;
        waitpid(pid, &status, 0);
        printf("Child process has exited\n");
    }
    return 0;
}

在這個改進的代碼中，父進程調(diào)用了waitpid函數(shù)等待子進程結(jié)束，這樣就不會產(chǎn)生僵尸進程 。

另一種避免僵尸進程的方法是利用信號機制 。當(dāng)子進程結(jié)束時，會向父進程發(fā)送SIGCHLD信號，我們可以在父進程中注冊SIGCHLD信號的處理函數(shù)，在處理函數(shù)中調(diào)用wait或waitpid來處理子進程的退出 。例如：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>

void sigchld_handler(int signo) {
    pid_t pid;
    int status;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        printf("Child process %d has exited\n", pid);
    }
}

int main() {
    struct sigaction sa;
    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1);
    }

    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子進程
        printf("Child process, PID: %d\n", getpid());
        exit(0);
    } else {
        // 父進程
        printf("Parent process, PID: %d\n", getpid());
        while (1) {
            sleep(1);
        }
    }
    return 0;
}

在這段代碼中，通過sigaction函數(shù)注冊了SIGCHLD信號的處理函數(shù)sigchld_handler，當(dāng)子進程結(jié)束時，會調(diào)用該處理函數(shù)來處理子進程的退出，從而避免了僵尸進程的產(chǎn)生 。

孤兒進程則是指父進程在子進程之前退出，導(dǎo)致子進程失去了父進程的管理，此時子進程就成為了孤兒進程 。這就像孩子還在成長（子進程還在運行），但家長卻提前離開了（父進程先退出） 。在 Linux 系統(tǒng)中，孤兒進程會被init進程（在 systemd 系統(tǒng)中通常是systemd進程）收養(yǎng)，init進程會負責(zé)回收孤兒進程的資源 。例如，下面這段代碼：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子進程
        printf("Child process, PID: %d, PPID: %d\n", getpid(), getppid());
        sleep(5);
        printf("Child process, PID: %d, PPID: %d\n", getpid(), getppid());
    } else {
        // 父進程
        printf("Parent process, PID: %d\n", getpid());
        exit(0);
    }
    return 0;
}

在這個例子中，父進程創(chuàng)建子進程后立即退出，子進程在睡眠 5 秒前后查看自己的父進程 ID，會發(fā)現(xiàn)父進程 ID 變成了init進程的 ID（通常為 1），說明子進程已經(jīng)被init進程收養(yǎng)，成為了孤兒進程 。

孤兒進程本身對系統(tǒng)并沒有太大的危害，因為init進程會妥善處理它們的資源回收 。但在某些情況下，我們可能需要對孤兒進程進行特殊的處理或監(jiān)控 。比如，如果我們希望在孤兒進程中執(zhí)行一些特定的清理操作，可以在子進程中檢測父進程是否已經(jīng)退出，如果發(fā)現(xiàn)父進程退出，就執(zhí)行相應(yīng)的清理代碼 。例如：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子進程
        sleep(1);
        if (getppid() == 1) {
            printf("I am an orphan process. Performing clean-up...\n");
            // 執(zhí)行清理操作
        }
        while (1) {
            sleep(1);
        }
    } else {
        // 父進程
        printf("Parent process, PID: %d\n", getpid());
        exit(0);
    }
    return 0;
}

在這段代碼中，子進程在睡眠 1 秒后檢查自己的父進程 ID，如果發(fā)現(xiàn)父進程 ID 為 1，說明自己成為了孤兒進程，然后執(zhí)行相應(yīng)的清理操作 。

五、Linux進程實戰(zhàn)演練

1. 案例一：優(yōu)化系統(tǒng)性能

在日常的 Linux 系統(tǒng)運維中，我們常常會遇到系統(tǒng)性能下降的情況，這時候就需要通過各種手段來找出問題所在并進行優(yōu)化。其中，找出占用資源高的進程并進行相應(yīng)處理是一個重要的優(yōu)化步驟。

假設(shè)我們在一臺運行著多個服務(wù)的 Linux 服務(wù)器上，突然發(fā)現(xiàn)系統(tǒng)響應(yīng)變得遲緩，用戶反饋一些應(yīng)用程序加載緩慢。這時候，我們首先想到的就是使用top命令來查看系統(tǒng)中各個進程的資源占用情況。在終端中輸入top命令后，我們會看到一個動態(tài)更新的界面，其中%CPU和%MEM列分別顯示了每個進程占用 CPU 和內(nèi)存的百分比。通過觀察這兩列數(shù)據(jù)，我們發(fā)現(xiàn)一個名為big_computation.py的 Python 進程占用了高達 80% 的 CPU 資源，同時占用了大量的內(nèi)存 。

top - 10:15:23 up 2 days,  1:23,  2 users,  load average: 2.50, 2.00, 1.50
Tasks: 200 total,   2 running, 198 sleeping,   0 stopped,   0 zombie
%Cpu(s): 80.0 us, 10.0 sy,  0.0 ni,  5.0 id,  5.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   7914.2 total,    123.4 free,   6543.2 used,   1247.6 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   1024.0 avail Mem 

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
12345 user1     20   0  512340 204800  12340 R  80.0  2.5   5:10.00 python big_computation.py

這個進程可能是導(dǎo)致系統(tǒng)性能下降的 “罪魁禍首”。如果這個進程是一個臨時的計算任務(wù)，且目前并非急需它運行，我們可以考慮終止它以釋放系統(tǒng)資源。通過ps -ef命令進一步確認該進程的詳細信息，獲取其 PID 為 12345，然后使用kill命令來終止它 。

ps -ef | grep big_computation.py
user1    12345     1  80 10:00 ?        00:05:10 python big_computation.py
kill 12345

執(zhí)行kill命令后，再次查看top命令的輸出，發(fā)現(xiàn)系統(tǒng)的 CPU 使用率和內(nèi)存占用率都有了明顯的下降，系統(tǒng)響應(yīng)速度也恢復(fù)正常 。

如果這個進程是一個長期運行的服務(wù)，我們不能直接終止它，但可以嘗試調(diào)整其優(yōu)先級，讓它少占用一些 CPU 資源，以保證其他更重要的進程能夠正常運行 。比如，使用renice命令將其優(yōu)先級降低。假設(shè)我們希望將其 nice 值調(diào)整為 10（nice 值越大優(yōu)先級越低） 。

renice -n 10 12345

執(zhí)行上述命令后，再次觀察top命令的輸出，會發(fā)現(xiàn)該進程的優(yōu)先級降低，CPU 使用率也有所下降，系統(tǒng)的整體性能得到了優(yōu)化 。通過這樣的實戰(zhàn)操作，我們能夠更好地掌握 Linux 系統(tǒng)中進程的監(jiān)控和優(yōu)化技巧，確保系統(tǒng)的穩(wěn)定高效運行 。

2. 案例二：進程間通信實現(xiàn)

進程間通信在 Linux 系統(tǒng)中有著廣泛的應(yīng)用場景，下面我們通過一個簡單的示例來展示使用管道實現(xiàn)進程間數(shù)據(jù)傳遞的方法。

假設(shè)我們有一個數(shù)據(jù)生成進程和一個數(shù)據(jù)處理進程，數(shù)據(jù)生成進程不斷生成一些隨機數(shù)，數(shù)據(jù)處理進程需要接收這些隨機數(shù)并進行平方計算 。我們可以使用管道來實現(xiàn)這兩個進程之間的數(shù)據(jù)傳遞。

首先，我們創(chuàng)建一個 C 語言程序來實現(xiàn)數(shù)據(jù)生成進程（producer.c） ：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

int main() {
    int pipe_fd[2];
    if (pipe(pipe_fd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子進程，作為數(shù)據(jù)處理進程
        close(pipe_fd[1]); // 關(guān)閉寫端
        int num;
        while (read(pipe_fd[0], &num, sizeof(int)) > 0) {
            int result = num * num;
            printf("Processed result: %d\n", result);
        }
        close(pipe_fd[0]); // 關(guān)閉讀端
    } else {
        // 父進程，作為數(shù)據(jù)生成進程
        close(pipe_fd[0]); // 關(guān)閉讀端
        srand(time(NULL));
        for (int i = 0; i < 5; i++) {
            int num = rand() % 100;
            write(pipe_fd[1], &num, sizeof(int));
            printf("Generated number: %d\n", num);
            sleep(1);
        }
        close(pipe_fd[1]); // 關(guān)閉寫端
        wait(NULL); // 等待子進程結(jié)束
    }

    return 0;
}

在這個程序中，首先創(chuàng)建一個管道，然后通過fork函數(shù)創(chuàng)建子進程。父進程作為數(shù)據(jù)生成進程，關(guān)閉管道的讀端，生成 5 個隨機數(shù)并通過管道的寫端發(fā)送給子進程 。子進程作為數(shù)據(jù)處理進程，關(guān)閉管道的寫端，從管道的讀端讀取數(shù)據(jù)，對讀取到的數(shù)據(jù)進行平方計算并打印結(jié)果 。

編譯并運行這個程序：

gcc -o producer producer.c
./producer

運行結(jié)果如下：

Generated number: 34
Processed result: 1156
Generated number: 78
Processed result: 6084
Generated number: 12
Processed result: 144
Generated number: 91
Processed result: 8281
Generated number: 56
Processed result: 3136

從運行結(jié)果可以清晰地看到，數(shù)據(jù)生成進程不斷生成隨機數(shù)并發(fā)送給數(shù)據(jù)處理進程，數(shù)據(jù)處理進程成功接收并進行了相應(yīng)的處理 。通過這個簡單的案例，我們展示了使用管道實現(xiàn)進程間通信的基本方法，在實際應(yīng)用中，可以根據(jù)具體需求對這個示例進行擴展和優(yōu)化，以滿足更復(fù)雜的進程間通信場景 。