一. 行程創建 — fork

1. 什么是fork()函式

頭檔案：#include <unistd.h>
函式原型：pid_t fork(void);

作用：從已存在行程中創建一個新行程，新行程為子行程，而原行程為父行程，

回傳值：給子行程中回傳0，父行程回傳子行程的pid，創建失敗回傳-1，

當一個行程呼叫fork之后，就有代碼完全相同的行程，而且它們都運行到相同的地方，通過判斷fork的回傳值并配合if陳述句可以讓父子行程分流，執行各自的代碼，看如下程式：

編譯運行：
$ ./myproc
child pid is 1645, fork return 0
father pid is 1000, fork return 1645

2. fork函式的作用

fork函式是存在于內核空間的，行程呼叫fork，控制轉移到內核中的fork代碼，內核完成如下任務：

1. 分配新的記憶體塊（物理空間）和內核資料結構（PCB、頁表、虛擬地址空間等）給子行程，
2. 將父行程大部分資料結構的內容拷貝給子行程（采用寫實拷貝，為了節省物理空間），
3. 添加子行程到系統行程串列當中（到這步時子行程已經創建成功），
4. fork回傳，開始調度器調度，先回傳誰由調度器決定，

3. fork補充

為何給子行程回傳0，給父行程回傳子行程的pid？

在現實生活中，父親：孩子 = 1：n，即一個父親可以有多個孩子，但一個孩子只能有一個父親，父親的多個孩子在一起時，父親會具體叫某個孩子的名字，這樣這個孩子才會知道父親在叫自己；但所有孩子都只會叫他們的父親爸爸，

行程也一樣，一個父行程有多個子行程，每個子行程要執行父行程交給它們的任務，想要知道子行程執行的怎么樣，父行程必須明確區分每個子行程，所以必須得到它們的pid，即子行程必須要被父行程特殊標識，而父行程不需要被子行程特殊標識，

子行程從哪里開始運行？

fork之后，父行程繼續往后運行，而子行程也是從fork之后的位置開始運行，誰先運行有調度器決定，當然子行程也跟父行程代碼是共用同一份的，只是子行程不執行fork之前的代碼罷了，

什么是寫實拷貝？

通常，父子代碼共享，當二者都不對代碼里的共用資料寫入時，資料也是共享的，當任意一方試圖寫入，作業系統會另外給要寫入的資料再開辟一塊空間，并更新頁表的映射關系，

fork使用場景

• 一個父行程希望復制自己，使父子行程同時執行不同的代碼段，例如，父行程等待客戶端請求，生成子行程來處理請求，
• 一個行程要執行一個與父行程毫不相干的程式，例如子行程從fork回傳后，呼叫exec函式，

fork呼叫失敗的原因

• 系統中行程總的數量過多，
• 實際用戶的可創建行程數超過了限制，

二. 行程退出

1. 行程退出的場景

1.1 正常退出

• 在main()函式中執行return代表行程的退出，其他普通函式的return不算，
• 任意位置呼叫 exit() 或 _exit()，都表示退出當前行程，

PS：通過行程的回傳值（也叫作退出碼）判斷運行結果是否正確，一般規定回傳0表示正確，非0表示錯誤，

我們可以通過命令：echo $? 來查看最近一次行程運行結果的退出碼，

1.2 例外退出

行程收到某個信號，而該信號使程式終止，比如下面程式，我們有進行野指標的訪問，編譯器檢查到后會報告給作業系統，之后系統發送段錯誤信號并終止行程：

PS：行程如果是例外退出，那么它的退出碼是沒有任何意義的，

2. exit 和 _exit

下面我們討論行程正常退出時的其中兩種方式，即exit和_exit，他們是兩個不同的函式，

2.1 函式介紹

_exit函式

頭檔案：#include <unistd.h>
原型：void _exit(int exit_code);

作用：直接終止整個行程，

引數：行程的退出碼，

exit函式

頭檔案：#include <unistd.h>
原型：void exit(int status)；

作用：先執行用戶通過 atexit或on_exit定義的清理函式，然后重繪緩沖區，最后呼叫_exit來終止整個行程，

引數：行程的退出碼，

2.2 二者的區別

exit()函式的底層最侄訓是會呼叫_exit()來終止整個行程，不過在這之前會完成一些該行程相關清理作業，

通過一段代碼感受一下，_exit因為沒有重繪緩沖區，所以什么都沒輸出，

三. 行程等待

1. 什么是行程等待

子行程想要完全退出，最后必須由父行程呼叫wait、waitpid函式來等待子行程退出，回收資源和獲取子行程退出狀態，

2. 為什么要有行程等待

子行程退出，父行程如果不管不顧，就可能造成‘僵尸行程’的問題，進而出現記憶體泄漏，行程一旦變成僵尸狀態，那就刀槍不入，“殺人不眨眼”的kill -9 也無能為力，因為誰也沒有辦法殺死一個已經死去的行程，而且，父行程派給子行程的任務完成的如何，我們需要知道，如，子行程運行完成，結果對還是不對，或者是否正常退出，

總結行程等待的作用有兩個：

1. 回收子行程資源，防止記憶體泄漏，
2. 獲取子行程的退出狀態，

3. 如何完成行程等待

有兩個函式可以完成行程等待：wait和waitpid，它們兩個都屬于系統呼叫函式，

3.1 函式介紹

wait

頭檔案：#include<sys/wait.h> 和 #include<sys/wait.h>
原型：pid_t wait(int* status)

引數：輸出型引數，獲取任意一個子行程退出狀態,不關心則可以設定成為NULL，

回傳值：等待成功（包括子行程正常和例外退出）回傳被等待行程pid、子行程還沒結束就繼續等、等待失敗回傳-1（行程不存在），

waitpid

頭檔案：#include<sys/types.h> 和 #include<sys/wait.h>
原型：pid_ t waitpid(pid_t pid, int *status, int options)

引數：

1. pid：指明要等待的子行程的pid，當設定為-1時代表等待任意子行程（此時與wait等效），
2. status：子行程的狀態碼，從中可以得到子行程的退出情況（正常退出還是例外退出）和退出碼，不關心的話可以設定為NULL，
3. options：當其為0時代表阻塞式等待，為WNOHANG時，為非阻塞式等待（檢測到子行程還未退出，會回傳0），

回傳值：

1. 等待成功（子行程正常或例外退出）回傳被等待行程的pid，
2. 子行程若還沒退出就繼續等或者回傳0，這取決于options是阻塞式等待或非阻塞式等待，
3. 等待失敗（子行程不存在）回傳-1，

總結：waitpid就是wait的升級版，它相比于wait而言可以指定要等待那個子行程（wait是等待任意一個子行程）和可以實作非阻塞式等待（wait只能阻塞式等待），

3.2 狀態碼

3.2.1 狀態碼的基本認識

wait和waitpid，都有一個status引數，即子行程的退出狀態碼，該引數是一個輸出型引數，由作業系統賦值，如果傳遞NULL，表示不關心子行程的退出資訊，否則作業系統會把這些子行程的退出資訊（包括信號和退出碼）通過status這個輸出型引數反饋給父行程，

status不能簡單的當作整形，而應當作位圖來看待，我們只研究status低16位元位，

• 其中低7位（對應下標0 - 6）代表子行程的退出信號，如果它非0代表子行程例外退出，
• 次低8位（對應下標8 - 15）代表子行程的退出碼，就是我們main函式中 return 和 exit或_exit的回傳值，只有等待成功（即子行程正常或例外退出）退出碼才有意義，

具體細節如下圖：

3.2.2 狀態碼的決議方法

決議狀態碼的方法有兩種：位運算和宏，

方法一：通過位運算決議狀態碼

1. status & 0x7f ：得到低7位的資料，即子行程的退出信號：如果為0表示子行程正常退出，非0表示例外退出，
2. (status>>8) & 0xff：得到次低8位的資料，即正常退出前提下子行程的退出碼，

樣例：

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

int main()
{
  pid_t pid = fork();
  if(pid==0)//子行程
  {
    // 子行程等待30秒后才退出
    sleep(30)
    exit(2);// 子行程退出碼為2
  }
  else if(pid>0)//父行程
  {
    // 父行程里定義的輸出型引數，傳入wait，用來獲取子行程的退出狀態
    int st=0;
    int ret=wait(&st);
    if(ret>0 && (st&0x7f)==0)//等待成功且子行程正常退出
    {
      printf("child exit code is:%d\n",(st>>8)&0xff);
    }
    else if(ret>0 && (st & 0x7f)>0)//等待成功且子行程例外退出
    {
      printf("child sig code is:%d\n",st&0x7f);
    }
  }
  return 0;
}  

正常情況等待30秒后輸出：
child exit code is:2

如果在等待30s期間，在另外一個終端通過kill -9 殺死子行程，會出現：
child sig code is:9

方法二：通過宏決議狀態碼

1、WIFEXITED(status) 即 "wait if exited"縮寫，若此值為真，表明行程正常結束，此時可通過 WEXITSTATUS(status) 即 "wait exit status"縮寫，來獲取行程退出碼，

 // 其中status為輸出型引數，就是子行程的退出狀態
 if(WIFEXITED(status))
 {
 	printf("退出碼為：%d\n", WEXITSTATUS(status));
 }

2、WIFSIGNALED(status) 即"wait signaled"縮寫，非0表明行程例外終止，此時可通過 WTERMSIG(status) 即"wait term signal"縮寫，獲取行程的退出信號，

 // 其中status為輸出型引數，就是子行程的退出狀態
 if(WIFSIGNALED(status))
 {
 	printf("退出信號為：%d\n", WTERMSIG(status));
 }

樣例：

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

int main()
{
  pid_t pid = fork();
  if(pid==0)//子行程
  {
    sleep(30);
    exit(2);
  }
  else if(pid>0)//父行程
  {
    int st=0;
    int ret=wait(&st);
    if(ret>0 && WIFEXITED(st))// 等待成功且子行程正常退出
    {
      printf("child exit code is:%d\n",WEXITSTATUS(st));
    }
    else if(ret>0 && WIFSIGNALED(st))// 等待成功且子行程例外退出
    {
      printf("child sig code is:%d\n",WTERMSIG(st));
    }
  }
  return 0;
}       

等待30秒
child exit code is:2

如果在等待30秒期間，在另外一個終端kill -9 殺死子行程，會出現
child sig code is:9

3.3 行程的等待方式

3.3.1 阻塞式等待

運行到wait或waitpid時，如果子行程還沒退出，父行程就停在這里不動直至子行程退出，這就叫做阻塞式等待，其中wait只能阻塞式等待，而waitpid的第三個引數option傳0時才是阻塞式等待，

#include <stdio.h>      
#include <stdlib.h>      
#include <unistd.h>      
#include <sys/wait.h>      
      
int main()    
{    
  pid_t pid = fork();                                                                                                
  if(pid==0)//子行程      
  {      
    sleep(30);      
    exit(2);      
  }      
  else if(pid>0)//父行程      
  {      
    int st=0;      
    int ret=waitpid(-1,&st,0);//阻塞式等待      
    if(ret>0 && WIFEXITED(st))    
    {                    
      printf("child exit code is:%d\n",WEXITSTATUS(st));
    } 
    else                                                                                                       
    {
      printf("wait child fail\n");
    }
    cout<<"I'm here<<endl;                               
  }      
  return 0;                        
}       

等待30秒
child exit code is:2
I’m here

3.3.2 非阻塞式等待

父行程運行到waitpid時，若子行程還在運行中就繼續做父行程自己的事情，完成后再來檢測子行程是否退出了，一直重復這個程序就是非阻塞式等待，waitpid的options傳WNOHANG即"wait no hang"，如果檢測到子行程還未退出，回傳0，

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

int main()
{
  pid_t pid = fork(); 
  if(pid==0)//子行程    
  {    
    sleep(3);    
    exit(2);    
  }
  else if(pid>0)//父行程    
  {    
    int st=0;    
    int ret=0;    
    do    
   {              
      ret=waitpid(-1, &st, WNOHANG);//非阻塞式等待
      // 檢測到子行程還沒有退出，父行程先做自己的事
      // 做完成后，再來檢測子行程是否退出
      if(ret==0)
      {                  
        sleep(1);                                                                                       
        printf("haha\n");   
      }                      
    }while(ret==0);
    // 等待完成后的處理         
    if(ret>0 && WIFEXITED(st))
    {  
      printf("child exit code is:%d\n",WEXITSTATUS(st));
    }  
    else         
    {           
      printf("wait child fail\n");
    }
    cout<<"I'm here<<endl;                       
  }    
  return 0;      
}                

編譯運行：
haha
haha
haha
child exit code is:2
I’m here

四. 行程替換

1. 什么是行程替換

行程替換是在當前行程pcb并不退出的情況下，替換當前行程正在運行的程式為新的程式（加載另一個程式在記憶體中，更新頁表資訊，初始化虛擬地址空間），

2. 為什么要有行程替換

子行程可以執行與父行程不同的程式，這樣子行程的執行就會更加獨立、靈活，

3. 行程替換的方法

3.1 exec系列函式介紹

其中有六種以exec開頭的函式，這一系列統稱exec函式，

頭檔案：#include <unistd.h>

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg,..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);

回傳值

• 這些函式如果呼叫成功則加載新的程式從啟動代碼開始執行,不再回傳，
• 如果呼叫出錯則回傳-1，原因包括：要替換程式的權限不允許、命令、選項不存在或者拼寫錯誤，
• 所以exec函式只有出錯的回傳值而沒有成功的回傳值，

引數理解

• path：可執行程式的路徑，
• file：可執行程式名稱，默認到PATH環境變數下的各目錄中搜尋該可執行程式，
• arg：即agrement，是一系列字串指標，才開始到結束每一個字串指標對應你要指向的命令或選項，最后必須以NULL結束，
• argv[]：即agrement value，是一個字串指標陣列，每一個元素對應可執行程式名稱及其所帶的引數，第一個引數為可執行檔案名字，最后一個元素必須以NULL結束，

命名理解
這些函式原型看起來很容易混,但只要掌握了規律就很好記，

• l : 即list，使用引數串列，
• v：即vector，把各個引數統一存盤到一個陣列里，
• p：使用可執行程式名，并從PATH環境變數下的路徑里進行尋找該可執行程式，
• e：多了envp[]陣列，使用新的環境變數代替呼叫行程的默認的環境變數，

3.2 exec系列函式使用

1、帶p與不帶p
帶p的話第一個引數就不用寫明可執行程式的路徑（絕對路徑或相對路徑都可以），只需寫出命令的名字就行，它會像系統執行命令一樣到PATH環境變數里它所指定的各目錄中搜尋該可執行檔案，

我們有兩個同一目錄下編譯后的可執行程式：myproc和myexec，他們的代碼如下

我們運行myproc程式，里面又通過 execl() 函式把當前程式替換為另一個程式myexec，
$ ./myproc
**** before exec ****
agrv[0] = myexec
agrv[1] = hello world

可以看到，經過 execl() 函式替換后，原程式最后的“after exec”不再執行，而是去執行另外一個程式myexec去了，即替換成功后不再回傳，

接下來我們使用帶有p的 execlp()，這樣我們第一個引數只需寫我們想要執行的程式的名字就可以了，

$ ./myproc
**** before exec ****
**** after exec ****

看結果，我們并沒有替換成功，因為環境變數PATH里的路徑中沒有myexec這個程式，我們把myexec拷貝到PATH下的其中一個路徑/bin后在試試看：
$ sudo cp ./myexec /bin
$ ./myproc
**** before exec ****
agrv[0] = myexec
agrv[1] = hello world

這次成功了，所以對于帶p的函式，必須先保證我們想要替換的程式必須能在環境變數PATH里找到才行，

2、 帶l和帶v
帶l（即list）的函式：你需要把命令和選項作為引數依次、逐個的傳入，最后要用空指標標識結束，

execl("myexec","myexec","hello world",NULL);

帶v（即vector）的函式：要求把命令和選項同時放到一個陣列里，最后要用空指標標識結束，呼叫時只需把陣列傳入即可，

char* const arr[]={"myexec","hello world",NULL};                                                       
execv("./myexec",arr);

3. 帶e的函式
包括 execle()、execvpe()，替換前可以傳遞一個指向環境字串的指標陣列，

引數例如char* myenv[ ] = {“AA=111”,“BB=222”,“CC=333”,NULL}，帶e的話就表示該函式讀取myenv[ ]陣列，而不使用默認的系統配置的環境變數，即使用傳入的環境變數，替換了默認的環境變數，

以 execle() 為例，我們重新撰寫同一目錄下的myproc.c和myexec.c兩個檔案


生成可執行程式后，編譯運行

$ ./myproc
**** before exec ****
AA=111
BB=222
CC=333

可以看到替換后的程式myexec確實使用了我們替換前傳入的自己寫的環境變數myenv，

3.3 小程式 — 實作一個簡易的Shell

什么是Shell

hell是指提供使用者使用界面的軟體，它接收命令，然后呼叫相關的應用程式，

Shell實作原理

shell作為父行程用fork建立子行程，用exec系列函式簇在子行程中運行用戶指定的程式，父行程shell用wait命令等待其子行程結束，wait系統呼叫同時從內核取得退出狀態或者信號序列以告知子行程是如何結束的，

代碼實作

include <iostream>                                                                                                   
#include <vector>    
#include <string.h>    
#include <sys/types.h>    
#include <sys/wait.h>    
#include <unistd.h>    
using namespace std;    
    
int main()    
{    
  while(1)    
  {    
    // 獲取命令列 + 決議命令列    
    cout<<"[myshell]$ ";    
    char* argList[20] = {nullptr};    
    string s;    
    string tmp;    
    int i = 0;    
    vector<string> v(20);    
    // 1、獲取一行命令列，存盤在string型別物件s中    
    getline(cin, s);    
    // 2、遍歷s，取出其中的每一個命令和選項，先放到陣列v中，完成字串內容的深拷貝    
    // 在把每一個元素的指標存到指標陣列argList里    
    for(auto e : s)    
    {    
      if(e == ' ')
      {
        v[i] = tmp;
        argList[i] = (char*)v[i].c_str();
        ++i;
        tmp.clear();
      }
      else 
      {
        tmp += e;
      }
    }
    // 最后一個命令還沒有存放，因為我們輸入的一行字串最后一個字符不是以空格結尾的
    argList[i] = (char*)tmp.c_str();
    // 3、父子行程分流完成各自的任務
    // 子行程：用execvp完成程式替換
    // 父行程：等待子行程
    pid_t id = fork();                                                                                                
    if(id == 0)// 子行程
    {
      execvp(argList[0], argList);
      exit(-1);
    }
    else if(id > 0)// 父行程
    {
      int status = 0;
      int ret = wait(&status);
      if(ret > 0)// a、等待成功
      {
        if(WIFEXITED(status))// 正常退出
        {
          cout<<"child exit code is："<<WEXITSTATUS(status)<<endl;
        }
        else// 例外退出
        {
          cout<<"abnormal exited"<<endl;
        }
      }
      else// b、等待失敗
      {
        cout<<"wait fail"<<endl;
      }                                                                                                               
    }
  }
  return 0;
}

效果演示：