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

一：如何實作行程控制

還記的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_CTXSW
	int oncpu;
#endif
#endif
......
.....
...

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

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

二：行程控制原語

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

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

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

1. 更新PCB中的資訊，比如修改行程狀態標志、將運行環境保存到PCB、從PCB恢復運行環境等等
2. 將PCB插入至合適的佇列
3. 分配/回收資源

（1）行程創建

A：概述

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

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

創建新行程的程序如下

1. 申請空白PCB：為新行程分配一個唯一的行程標識號，并申請一個空白的PCB，若PCB申請失敗，則行程創建失敗
2. 為新行程分配所需資源：為新行程的程式和資料及用戶堆疊分配必要的記憶體空間，注意若資源不足，進入阻塞態等待資源
3. 初始化PCB：主要包括初始化標志資訊、初始化處理機狀態資訊和初始化處理機控制資訊，以及設定行程的優先級等等
4. 將PCB插入就緒佇列：若行程就緒佇列能夠接納新行程，則將新行程插入就緒佇列，等待被調度運行

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

1. 用戶登錄：分時系統中，用戶登錄成功，系統會為其建立一個新的行程，比如Linux中的bash
2. 作業調度：多道批處理系統中，有新的作業放入記憶體時，會為其建立一個新的行程
3. 提供服務：用戶向作業系統提出某些請求時，會建立一個行程處理該請求
4. 應用請求：由用戶行程主動請求創建一個子行程，比如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;
}

運行效果如下

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

1. 它們的邏輯關系有些特點
   
2. 從上面的動圖可以發現，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)//父行程回傳的是子行程ID
		printf("我是父行程，我的id是：%d,我的孩子id是%d\n",getpid(),ret);
	else if(ret==0)//子行程fork回傳值是0
		printf("我是子行程，我的id是%d，我的父親id是%d\n",getpid(),getppid());
	else
		printf("行程創建失敗\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);
		}
	}
	else
		printf("行程創建失敗\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：概述

作業系統終止行程的程序如下：

1. 根據被終止行程的識別符號，檢索PCB，從中讀出該行程的狀態
2. 若被終止行程處于執行狀態，立即終止該行程的執行，將處理機資源分配給其他行程
3. 若該行程還有子孫行程，則應將其所有子孫行程終止
4. 將該行程所有用的全部資源歸還給作業系統或其父行程
5. 將其PCB從所在佇列中洗掉

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

1. 正常結束：表示行程的任務已經完成并準備退出運行
2. 例外結束：表示行程在運行時，發生了某種例外事件，使程式無法繼續運行，比如存盤區越界、保護錯誤、非法指令、特權指令錯誤、運行超時、浮點例外等等
3. 外界干預：指行程相應外界的請求而終止運行，比如操作員或作業系統干預、父行程請求或父行程終止

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
    }
    else
      printf("行程創建失敗\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);
      }
    }
    else
      printf("行程創建失敗\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：概述

行程阻塞執行程序如下

1. 找到將要被阻塞行程的標識號對應的PCB
2. 若該行程為運行態，則需要保護其現場，將其狀態轉換為阻塞態，停止運行
3. 把該PCB插入相應事件的等待佇列，將處理機資源調度給其他就緒行程

引起行程阻塞的事件有

1. 需要等待系統分配某種資源
2. 需要等待相互合作的其他行程完成作業

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
    }
    else
      printf("行程創建失敗\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
    }
    else
      printf("行程創建失敗\n");

    sleep(1);
    return 0;
}

效果如下

③：行程非阻塞式等待

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

（4）行程喚醒（Wake）

喚醒行程的執行程序如下

1. 在該事件的等待佇列中找到相應行程的PCB
2. 將其從等待佇列中移除，并置其狀態為就緒態
3. 把該PCB插入就緒佇列，等待調度程式調度

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

（5）行程切換

行程切換的程序如下

1. 保存處理機背景關系，包括程式計數器和其他暫存器
2. 更新PCB資訊
3. 把行程的PCB移入相應的佇列，如就緒、在某事件阻塞等佇列
4. 選擇另一個程式行程執行，并更新其PCB
5. 更新記憶體管理的資料結構
6. 恢復處理機背景關系

引起行程切換的事件有：

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