文章目錄

• 一：如何實現進程控制
• 二：進程控制原語
• • （1）進程創建
  • • A：概述
    • B：補充-Linux中的創建進程操作
    • • ①：fork()
      • ②：fork()相關問題
  • （2）進程終止
  • • A：概述
    • B：補充-僵尸進程與孤兒進程
    • • ①：僵尸進程
      • ②：孤兒進程
  • （3）進程阻塞(Block)/等待(Wait)
  • • A：概述
    • B：補充-Linux中的進程等待
    • • ①：為什么進程需要被等待/阻塞
      • ②：進程阻塞式等待
      • ③：進程非阻塞式等待
  • （4）進程喚醒（Wake）
  • （5）進程切換

進程控制是指對系統中所有進程實施有效的管理，它具有創建新進程、撤銷已有進程、實現進程狀態轉換等功能。可以簡單理解為實現進程狀態轉換

一：如何實現進程控制

還記的PCB嗎？ 對，就是它。在學校中學校如果想要對我們進行管理，依靠的就是你的綜測，在操作系統中要對進程進行控制依靠的就是PCB

在Linux的task struct結構體定義中（Linux是用C語言寫的）大家可以很明顯的看到一個字段叫做state

struct task_struct {volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */void *stack;atomic_t usage;unsigned int flags; /* per process flags, defined below */unsigned int ptrace;int lock_depth; /* BKL lock depth */#ifdef CONFIG_SMP #ifdef __ARCH_WANT_UNLOCKED_CTXSWint oncpu; #endif #endif ...... ..... ...

既然這樣，操作系統在實現進程狀態控制時，就像記錄學生成績一樣，進行刪刪改改，修修補補即可（當然沒有這么簡單）

• 創建進程：需要初始化PCB、分配系統資源
• 創建態->就緒態：修改PCB內容和相應隊列
• 就緒態->運行態：恢復進程運行環境、修改PCB內容和相應隊列
• 運行態->終止態：回收進程擁有的資源，撤銷PCB
• 運行態->就緒態：(進程切換)需要保存進程運行環境、修改PCB內容和相應隊列
• 運行態->阻塞態：需要保存進程運行環境、修改PCB內容和相應隊列
• 阻塞態->就緒態：需要保存進程運行環境、修改PCB內容和相應隊列。如果等待的是資源，則還需要為進程分配系統資源

二：進程控制原語

原語就是指原子性操作。“要么做要么不做，如果做了你就做完”，這就是原子性操作的含義，不能出現模棱兩可的情況

進程控制是一個高度敏感的話題，如果出現控制方面的二義性問題話會導致一些不堪設想的后果，所以需要使用原語進行進程控制，采用“關中斷”“開中斷”實現原語操作，在執行期間不允許中斷

接下來的三種原語中，無論哪一個原語，它們所做的事情無外乎以下三種

更新PCB中的信息。比如修改進程狀態標志、將運行環境保存到PCB、從PCB恢復運行環境等等

將PCB插入至合適的隊列

分配/回收資源

（1）進程創建

A：概述

一個進程創建另一個進程，此時創建者稱為父進程，被創建的進程稱之為子進程

• 子進程可以繼承父進程所擁有的資源；子進程撤銷時，應將其從父進程哪里獲得的資源還給父進程

創建新進程的過程如下

申請空白PCB：為新進程分配一個唯一的進程標識號，并申請一個空白的PCB，若PCB申請失敗，則進程創建失敗

為新進程分配所需資源：為新進程的程序和數據及用戶棧分配必要的內存空間，注意若資源不足，進入阻塞態等待資源

初始化PCB：主要包括初始化標志信息、初始化處理機狀態信息和初始化處理機控制信息，以及設置進程的優先級等等

將PCB插入就緒隊列：若進程就緒隊列能夠接納新進程，則將新進程插入就緒隊列，等待被調度運行

可以引起進程創建的事件有

用戶登錄：分時系統中，用戶登錄成功，系統會為其建立一個新的進程。比如Linux中的bash

作業調度：多道批處理系統中，有新的作業放入內存時，會為其建立一個新的進程

提供服務：用戶向操作系統提出某些請求時，會建立一個進程處理該請求

應用請求：由用戶進程主動請求創建一個子進程。比如Linux中的系統調用fork

B：補充-Linux中的創建進程操作

上面所敘述的均是概述，并沒有針對特定的操作系統，因此這里以Linux為例，展示一下在Linux中創建進程等操作，加深同學們的理解。如果想要了解更多請移步：Linux系統編程10：進程入門之系統編程中最重要的概念之進程&&進程的相關操作&&使用fork創建進程

fork()函數是用來創建進程的，在fork函數執行后，如果成功創建新進程就會出現兩個進程，一個是子進程，一個是父進程，fork函數有兩個返回值

①：fork()

1：演示一：創建子進程

編寫如下C語言文件，進入主函數后，執行fork函數，創建進程

#include <stdio.h> #include <unistd.h>int main() {printf("執行到fork函數之前其進程為：%d，其父進程為：%d\n",getpid(),getppid()); sleep(1);fork();sleep(1);prinf("這個進程id為:%d,它的父進程id為%d\n",getpid(),getppid());sleep(1);return 0; }

運行效果如下

根據上面程序的運行效果，似乎可以發現下面比較值得注意的幾點

它們的邏輯關系有些特點

從上面的動圖可以發現，fork()函數調用完成之后，它們似乎是同時輸出的，這是否告訴我們這兩個進程是同時進行的？ 或許它可以被畫成這樣？

2：演示二：創建子進程
前面說過，fork有兩個返回值。官方手冊中是這樣解釋到的

• 在父進程中，fork返回新創建子進程的ID
• 在子進程中，fork返回0
• 未能創建，fork返回負值

在子進程中，fork函數返回0，在父進程中，fork返回新創建子進程的ID。我們可以通過fork返回值判斷當前進程是什么進程。

根據以上描述，編寫C語言代碼，使用fork函數的返回值來進行分流

#include <stdio.h> #include <unistd.h>int main() {prinf("還沒有執行fork函數的本進程為：%d\n",getpid());pid_t=fork();//其返回值是pid類型的sleep(1);if(ret>0)//父進程返回的是子進程IDprintf("我是父進程，我的id是：%d,我的孩子id是%d\n",getpid(),ret);else if(ret==0)//子進程fork返回值是0printf("我是子進程，我的id是%d，我的父親id是%d\n",getpid(),getppid());elseprintf("進程創建失敗\n");sleep(1);return 0; }

效果如下
3：演示三：一個大的問題
為了方便演示，修改上述代碼如下，為每個if語句塊內加入死循環，使其能不斷輸出

#include <stdio.h> #include <unistd.h>int main() {prinf("還沒有執行fork函數的本進程為：%d\n",getpid());pid_t=fork();//其返回值是pid類型的sleep(1);if(ret>0)//父進程返回的是子進程ID{while(1){printf("----------------------------------------------------------------\n");printf("我是父進程，我的id是：%d,我的孩子id是%d\n",getpid(),ret);sleep(1);}}else if(ret==0)//子進程fork返回值是0{while(1){printf("我是子進程，我的id是%d，我的父親id是%d\n",getpid(),getppid());sleep(1);}}elseprintf("進程創建失敗\n");sleep(1);return 0; }

效果如下

同時再使用之前的命令查看這個進程，發現也是兩個進程

但是這里有一個很大的問題：我們知道，不論是哪種編程語言，if-else執行時每次只能執行一路，怎么可能同時執行多路，同時每個if語句塊內都有死循環，一個循環未結束，又怎么可能去執行其他語句呢

其實在Linux中，進程創建會形成鏈表，父進程創建子進程，那么父進程的進程指針會指向子進程ID。所以這兩個進程是同時運行的

②：fork()相關問題

1.如何理解進程創建
前面說過，操作系統在進行管理時，必然遵循“先描述，再組織”的原則，所以在進行進程管理時。首先會創建相應的task_struct，寫入有關信息，然后和你編寫好的代碼共同組成進程

2.為什么fork有兩個返回值
根據上面的描述，可以大致描述fork函數的執行邏輯如下

pid_t fork() {//先描述，再組織，所以首先為子進程創建結構體struct task_struct* p=malloc(struct task_struct);//以下邏輯就是寫入屬性信息p->XX=father->XX;....p->status=run;p->id=1888;//到這里之前，子進程創建完畢return p->id;}

其實，進程數據=代碼+數據，代碼是共享的，數據是私有的，上述邏輯中return之前的語句是父進程執行，結果就是生成了子進程，等執行return語句時，子進程已經生成，于是父子進程同時執行這一條語句，又因為數據是私有的，所以各自返回不同的值

執行完fork之后，父進程pid不等于0，子進程pid等于0。這兩個進程都是獨立的，存在于不同地址中，不是公用的。
fork把進程當前的情況進行拷貝，執行fork時，fork只拷貝下一個要執行的代碼到新的進程

為了說明變量不共用，可以編寫一個C語言代碼如下，同一個變量分別在父進程和子進程中修改

#include <stdio.h> #include <unistd.h>int main() {int cout=0;printf("還未執行fork函數的cout=%d\n",cout);pid_t ret=fork();if(ret>0){cout+=1;//父進程cout=1；printf("父進程：cout=%d\n",cout);}else if(ret==0){cout+=10;//子進程cout=10；printf("子進程：cout=%d\n",cout);}else printf("失敗\n");sleep(1);return 0;}

結果如下，可以發現它們不公用變量

3.為什么兩個返回值不一樣

其實很好理解，創建進程時相當于形成了鏈表（Linux）中，父進程指向子進程，所以返回的是子進程的ID，而子進程沒有它的子進程，所以返回0。

再者從現實生活中理解，一個孩子肯定知道它只有一個爹，而一個爹可能有多個孩子，所以子進程在標識父進程時就不要做那么多的區分，但是父進程可能有多個子進程，它與它在區分不同的子進程時必須要使用PID。

4.為什么代碼是共享的，數據是私有的

首先代碼是不可修改的（還記得代碼段，數據段嗎？），還有下面的常量字符串其實反映的也是這個道理

const char* str1="Hello World"; const char* str2="Hello World"; //str1和str2地址相同

對于數據來說，如果數據不私有，造成的后果就是同一份數據在父子進程之間改來改去引起混亂

（2）進程終止

A：概述

操作系統終止進程的過程如下：

根據被終止進程的標識符，檢索PCB，從中讀出該進程的狀態

若被終止進程處于執行狀態，立即終止該進程的執行，將處理機資源分配給其他進程

若該進程還有子孫進程，則應將其所有子孫進程終止

將該進程所有用的全部資源歸還給操作系統或其父進程

將其PCB從所在隊列中刪除

引起進程終止的事件主要有：

正常結束：表示進程的任務已經完成并準備退出運行

異常結束：表示進程在運行時，發生了某種異常事件，使程序無法繼續運行。比如存儲區越界、保護錯誤、非法指令、特權指令錯誤、運行超時、浮點異常等等

外界干預：指進程相應外界的請求而終止運行。比如操作員或操作系統干預、父進程請求或父進程終止

B：補充-僵尸進程與孤兒進程

上面所敘述的均是概述，并沒有針對特定的操作系統，因此這里以Linux為例，展示一下在Linux中由于進程終止而產生的一些現象，加深同學們的理解。如果想要了解更多請移步：Linux系統編程10：進程入門之系統編程中最重要的概念之進程&&進程的相關操作&&使用fork創建進程

①：僵尸進程

簡單點來說：僵尸進程就是子進程已經退出了，父進程還在運行當中，父進程沒有讀取到子進程的狀態，子進程就會進入僵尸狀態

使用下面的C語言程序模擬一個僵尸程序，子進程在10秒后利用exit退出，但是父進程一直在運行

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() {// printf("還沒執行fork函數時的本進程為：%d\n",getpid());pid_t ret=fork();//其返回值類型是pid_t型的sleep(1);if(ret>0)//父進程返回的是子進程ID{while(1){printf("----------------------------------------------------\n");printf("父進程一直在運行\n");sleep(1);}}else if(ret==0)//子進程fork返回是0{int count=0;while(count<=10){printf("子進程已經運行了%d秒\n",count+=1);sleep(1);}exit(0);//讓子進程運行10s}elseprintf("進程創建失敗\n");sleep(1);return 0; }

效果如下，可以發現，在10s后，子進程已經退出，父進程還在運行

根據上面的定義，當子進程先退出，父進程還在運行，由于讀取不到子進程的退出狀態，所以子進程會變為僵尸狀態。為了方便演示，使用下面的腳本，來每1s監控進程

while :; do ps axj | head -1 && ps axj | grep a.out | grep -v grep;sleep 1;echo "###########";done

效果如下，可以發現當子進程結束后，父進程還是在運行，此時進程太變為Z，也就是僵尸狀態

那么為什么有僵尸進程呢？

其實道理也很簡單，子進程是由父進程創建的，父進程之所以要創建子進程，其目的就是要給子進程分配任務，那么在這個過程中，子進程平白無故的沒了，而父進程卻不知道子進程到底把自己交給它的任務完成的怎么樣，成功了還好，失敗的話就能再交代一個進程去操作。
所以進程結束時一定要給父進程返回一個狀態，父進程一直不讀取這個狀態的話，那么子進程就會一直卡在僵尸狀態，其中像代碼這些資源已經被釋放，但是這個進程卻沒有真正退出，因為PCB還在維護它，直到父進程讀取到它的狀態，才能進入死亡狀態

• 進程控制塊中，一個進程退出后，還有一個退出碼返回給父進程，如下是Linux內核中關于這部分的定義
  
• 在Linux中一行命令就是一個進程，那么這個命令的父進程是bash，那么命令在結束的一瞬間也會給bash返回一個狀態碼，bash作為父進程，就是依靠這個返回碼來判斷命令是否正常結束，如果狀態碼為某一個值即可判定為沒有這樣的命令。在Linux中可以用echo $?來查看上一個輸入命令的狀態返回碼，命令正確返回0，否則返回非0
  

②：孤兒進程

孤兒進程就是父進程沒了，子進程還在。那么根據上面的僵尸進程，子進程在退出后由于沒有父進程來讀取它的狀態，所以會一直卡在僵尸狀態，那么這樣就會存在一個問題，它的內存資源誰來回收，通俗點將就會造成 內存泄漏

修改上面的代碼，讓父進程先掛，如下

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() {// printf("還沒執行fork函數時的本進程為：%d\n",getpid());pid_t ret=fork();//其返回值類型是pid_t型的sleep(1);if(ret>0)//父進程返回的是子進程ID{int cout=0;while(cout<10){printf("----------------------------------------------------\n");printf("父進程運行了%d秒\n",cout+=1);sleep(1);}exit(0);//讓父進程掛了}else if(ret==0)//子進程fork返回是0{int count=0;while(1){printf("子進程已經運行了%d秒\n",count+=1);sleep(1);}}elseprintf("進程創建失敗\n");sleep(1);return 0; }

效果如下，這里還有一個現象就是，當父進程掛了之后，子進程一直在運行，并且ctrl+C，無法結束進程。這是因為ctrl+C此時結束的是父進程，但是父進程早已結束，子進程像孤兒一樣四處游蕩

除非使用killl才能將其殺掉

那么問題來了，這個進程難道一直要占用資源嗎，其實操作系統在設計的時候就考慮到了這一步。所以一旦父進程先掛了，那么這個子進程就會被1號進程領養

依然使用下面腳本進行觀察

while :; do ps axj | head -1 && ps axj | grep a.out | grep -v grep;sleep 1;echo "###########";done

效果如下，可以發現，當父進程掛了，這個進程的ppid，也就是父進程更換為了1號進程

1號進程是什么呢，其實就是systemd

（3）進程阻塞(Block)/等待(Wait)

A：概述

進程阻塞執行過程如下

找到將要被阻塞進程的標識號對應的PCB

若該進程為運行態，則需要保護其現場，將其狀態轉換為阻塞態，停止運行

把該PCB插入相應事件的等待隊列，將處理機資源調度給其他就緒進程

引起進程阻塞的事件有

需要等待系統分配某種資源

需要等待相互合作的其他進程完成工作

B：補充-Linux中的進程等待

上面所敘述的均是概述，并沒有針對特定的操作系統，因此這里以Linux為例，展示一下Linux中的進程等待現象，加深同學們的理解。如果想要了解更多請移步：Linux系統編程17：進程控制之進程等待&&為什么進程需要被等待&wait方法和waitpid方法&&阻塞和非阻塞等待

①：為什么進程需要被等待/阻塞

前面的例子中說過，子進程退出后就變成了僵尸狀態，一旦變成僵尸狀態，這個子進程就如同僵尸一樣，殺也殺不死（因為它已經死了），所以它必須需要讓父進程讀取到它的狀態，回收子進程信息。只有這樣，子進程才能得到“救贖”，“魂魄”才能歸天，這屬于進程需要被等待的一個典型例子

②：進程阻塞式等待

在上面的僵尸進程的例子中，修改代碼子進程在10s后退出，父進程在10s后繼續運行，運行至第15s，跳出循環，加入語句wailt(NULL)以回收子進程

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() {// printf("還沒執行fork函數時的本進程為：%d\n",getpid());pid_t ret=fork();//其返回值類型是pid_t型的sleep(1);if(ret>0)//父進程返回的是子進程ID{int count=1;while(count<=15){printf("----------------------------------------------------\n");printf("父進程運行了%d秒\n",count);count++;sleep(1);}wait(NULL);//回收子進程}else if(ret==0)//子進程fork返回是0{int count=1;while(count<=10){printf("子進程已經運行了%d秒\n",count);count++;sleep(1);}exit(0);//讓子進程運行10s}elseprintf("進程創建失敗\n");sleep(1);return 0; }

如下可以發現，當父進程將子進程回收后，僵尸進程也消失了

如果父進程里只寫上wait(NULL)，那么就表示父進程阻塞在這里，等著子進程死亡，回收子進程

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() {// printf("還沒執行fork函數時的本進程為：%d\n",getpid());pid_t ret=fork();//其返回值類型是pid_t型的sleep(1);if(ret>0)//父進程返回的是子進程ID{printf("父進程正在等待子進程死亡\n");wait(NULL);//進程阻塞printf("子進程已經死亡，父進程退出\n");exit(0);}else if(ret==0)//子進程fork返回是0{int count=1;while(count<=10){printf("子進程已經運行了%d秒\n",count);count++;sleep(1);}exit(0);//讓子進程運行10s}elseprintf("進程創建失敗\n");sleep(1);return 0; }

效果如下

③：進程非阻塞式等待

這一部分需要用到大量Linux基礎知識，如有興趣，可移步進行系統學：Linux系統編程17：進程控制之進程等待&&為什么進程需要被等待&wait方法和waitpid方法&&阻塞和非阻塞等待

（4）進程喚醒（Wake）

喚醒進程的執行過程如下

在該事件的等待隊列中找到相應進程的PCB

將其從等待隊列中移除，并置其狀態為就緒態

把該PCB插入就緒隊列，等待調度程序調度

值得注意的是：Block和Wakeup作用剛好相反，必須成對使用。其中Block是由被阻塞進程自我調用實現的；Wakeup則是由一個與被喚醒進程合作或其他相關進程調用實現的

（5）進程切換

進程切換的過程如下

保存處理機上下文，包括程序計數器和其他寄存器

更新PCB信息

把進程的PCB移入相應的隊列，如就緒、在某事件阻塞等隊列

選擇另一個程序進程執行，并更新其PCB

更新內存管理的數據結構

恢復處理機上下文

引起進程切換的事件有：

• 當前進程時間片已到
• 有更高優先級的進程到達
• 當前進程主動阻塞
• 當前進程終止

總結

以上是生活随笔為你收集整理的(王道408考研操作系统)第二章进程管理-第一节3：进程控制（配合Linux讲解）的全部內容，希望文章能夠幫你解決所遇到的問題。

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