一、程序概念

程序是作業系統中資源分配的最小單位，而執行緒是排程的最小單位。

一個程序，主要包含三個元素：

a)        一個可以執行的程式；

b)        和該程序相關聯的全部資料（包括變數，記憶體空間，緩衝區等等）；

c)        程式的執行上下文（execution context）。

不妨簡單理解為，一個程序表示的，就是一個可執行程式的一次執行過程中的一個狀態。作業系統對程序的管理，典型的情況，是通過程序表完成的。程序表中的每一個表項，記錄的是當前作業系統中一個程序的情況。對於單 CPU的情況而言，每一特定時刻只有一個程序佔用CPU，但是系統中可能同時存在多個活動的（等待執行或繼續執行的）程序。

二、程序識別符號

每一個程序都有一個非負整形表示的唯一程序ID。雖然程序ID總是唯一的，但是可以重用。當一個程序終止，其之前被分配的程序ID就可以再次被使用。

三、建立程序  fork() 函式

fork()是程序的核心函式，由fork建立的新程序被成為子程序。

eg:

有一個現有的程序可以呼叫fork函式建立一個新的程序：

＃include <unistd.h>

pid_t fork(void);

fork函式被呼叫一次，但返回兩次。兩次返回的唯一區別是子程序的返回值是0，而父程序的返回值則是新子程序的程序ID。

將子程序ID返回給父程序的理由是：因為一個程序的子程序可以有多個，但是沒有一個函式能使一個程序可以獲得其所有子程序的程序ID。

fork使子程序獲得返回值為0的原因：一個程序只會有一個父程序，所以子程序總是可以呼叫getppid用來獲得其父程序的程序ID。

子程序和父程序繼續執行fork呼叫之後的指令（原因在文章的後面部分會解釋）。子程序是父程序的副本。子程序可以獲得父程序的資料空間、堆和棧的副本，但是父子程序並不共享這些儲存空間，父子程序共享這些正文段。

fork函式簡單示例：

#include "apue.h"

int     glob = 6;
char    buf[] = "a write to stdout\n";

int main(void)
{
        int     var;
        pid_t   pid;

        var = 88;
        if (write(STDOUT_FILENO, buf, sizeof(buf)-1) != sizeof(buf)-1)//write函式將buf中的內容寫到標準輸出流中，此處製作輸出使用。
        err_sys("write error");
        printf("before fork\n");

        if ((pid = fork()) < 0) {
                err_sys("fork error");
        } else if (pid == 0) {
                glob++;
                var++;
        } else {
                sleep(2);  //學過Linux的都知道，在fork()之後，是父程序先執行還是子程序先執行取決於核心的排程演算法。所以在這裡為了讓子程序先執行，我們
                             先讓父程序sleep 2秒，但是2秒鐘不一定夠，所以不一定能夠保證子程序先執行。
 }

 

編譯、執行 上述程式碼段之後可得如下結果：

[email protected]:~$ gcc -g test1.c -o test1 libapue.a   //編譯 
[email protected]:~$ ./test1               //執行
a write to stdout
before fork
pid = 20266, glob = 7, var = 89
pid = 20265, glob = 6, var = 88

程式碼分析：

a)、當你看到fork的時候，你可以把fork理解成“分叉”，在分叉的同時，生成的一個子程序複製了父程序的基本所有的東西，包括程式碼、資料和分配給程序的資源。也就是子程序幾乎是和父程序是一模一樣的。但是子程序可能會根據不同情況呼叫其他函式。比如exec函式。

b)、在語句pid=fork()之前，只有一個程序在執行這段程式碼，但在這條語句之後，就變成兩個程序在執行了，這兩個程序的幾乎完全相同，將要執行的下一條語句都是if(pid<0)……

　　為什麼兩個程序的pid不同呢，這與fork函式的特性有關。fork呼叫的一個奇妙之處就是它僅僅被呼叫一次，卻能夠返回兩次，它可能有三種不同的返回值：

　　1)在父程序中，fork返回新建立子程序的程序ID;

　　2)在子程序中，fork返回0;

　　3)如果出現錯誤，fork返回一個負值;

　　在fork函式執行完畢後，如果建立新程序成功，則出現兩個程序，一個是子程序，一個是父程序。在子程序中，fork函式返回0，在父程序中，fork返回新建立子程序的程序ID。我們可以通過fork返回的值來判斷當前程序是子程序還是父程序。解釋一下pid的值為什麼在父子程序中不同。“其實就相當於連結串列，程序形成了連結串列，父程序的pid(p 意味point)指向子程序的程序id, 因為子程序沒有子程序，所以其pid為0.

c)、fork出錯可能有兩種原因：

　　1)當前的程序數已經達到了系統規定的上限，這時errno的值被設定為EAGAIN。

　　2)系統記憶體不足，這時errno的值被設定為ENOMEM。

d)、建立新程序成功後，系統中出現兩個基本完全相同的程序，這兩個程序執行沒有固定的先後順序，哪個程序先執行要看系統的程序排程策略。

　　每個程序都有一個獨特(互不相同)的程序識別符號(process ID)，可以通過getpid()函式獲得，還有一個記錄父程序pid的變數，可以通過getppid()函式獲得變數的值。

e)、fork呼叫執行完畢後，出現兩個程序，

　　或許有人問兩個程序的內容完全一樣，為什麼列印的結果不一樣啊，那是因為判斷條件的原因，上面列舉的只是程序的程式碼和指令，還有變數。

　　執行完fork後，程序1的變數為var=88，pid!=0(父程序)。程序2的變數為var=88，pid=0(子程序)，這兩個程序的變數都是獨立的，存在不同的地址中，不是共用的，這點要注意。可以說，我們就是通過pid來識別和操作父子程序的。

f)、還有人可能問為什麼不是從#include處開始複製程式碼的

     這是因為fork是把程序當前的情況拷貝一份，執行fork時，程序已經執行完了int var=88;fork只拷貝下一個要執行的程式碼到新的程序。(因為FORK是複製產生一個新的程序，因此新的程序與舊的程序之間的上下文，如暫存器上下文等是一致的，也就是說兩個程序的變數值，PC指標值也是一樣的在這裡：PC是指暫存器PC，它裡邊的值總是指向當前程式的執行點的地址，因此兩個程序都是在同一個位置開始執行)。

四、fork難度＋＋

a)、首先看一段程式碼：

#include "apue.h"

int main(void)

{
      int i=0;
      pid_t pid;

      for(i=0;i<2;i++)

       {

                if((pid=fork())<0){

                        printf("forkerror\n");

                }else if(pid==0){

                       printf("%d,childself's pid=%d,parent's pid=%d,returnid=%d\n",i,getpid(),getppid(),pid);

               }else{

                       printf("%d,parentself's pid=%d,parent's father's pid=%d,returnid=%d\n",i,getpid(),getppid(),pid);

                        sleep(2);//為了確保（1）、在i＝0時子程序先於父程序執行fork呼叫；
                                           （2）、父程序在子程序之後退出，這樣可以保證子程序不會變成孤兒程序而過繼給init程序；
                  }

       }

       exit(0);

}

編譯並執行：

[email protected]:~$ gcc -g test32.c -o test32 libapue.a 
[email protected]:~$ ./test32
0,parentself's pid=21352,parent's father's pid=31055,returnid=21353
0,childself's pid=21353,parent's pid=21352,returnid=0
1,parentself's pid=21353,parent's father's pid=21352,returnid=21354
1,childself's pid=21354,parent's pid=21353,returnid=0
1,parentself's pid=21352,parent's father's pid=31055,returnid=21355
1,childself's pid=21355,parent's pid=21352,returnid=0

分析：

第一步：在父程序中，當指令執行for迴圈時，i=0，接著執行fork，fork執行完後，系統中出現兩個程序，分別是21352和21353。可以看到父程序21352的父程序是31055，子程序21353的父程序正好是21352。我們用一個連結串列來表示這個關係：

　　31055->21352->21353

第一次fork後，21352(父程序)的返回值 returnid=21353，而子程序21353的返回值rturnid=0。原因是：fork函式被呼叫一次產生兩個返回值，父程序得到的返回值是它所產生的子程序的程序ID，而子程序得到的返回值是0。

所以會有如下列印結果：

0,parentself's pid=21352,parent's father's pid=31055,returnid=21353
0,childself's pid=21353,parent's pid=21352,returnid=0

第二步：有上面的結果可知，當i=1時，子程序21353先執行，接著執行fork，系統中又新增一個新程序21354，對於此時程序鏈為：21352(當前程序的父程序)->21353(當前程序)->21354(被建立的子程序)。從輸出可以看到21353原來是21352的子程序，現在變成21354的父程序。父子程序是相對的，這個大家應該容易理解。只要當前程序執行了fork，該程序就變成了父程序了，就打印出了parent。

　　對於程序21352，當i=1時，接著執行fork，該程序建立一個程序號為21355的子程序，對於此程序程序鏈為：31055-(當前程序的父程序)>21352(當前程序)->21355(被建立的子程序)。

第三步：第二步的時候建立了兩個程序21354和21355，，這兩個程序執行完printf函式後就結束了，所以這兩個程序無法進入第三次迴圈，無法執行fork，故returnid＝ 0;其他程序也是如此。
    以下是程序21354和21355打印出的結果：
 

1,childself's pid=21354,parent's pid=21353,returnid=0
1,childself's pid=21355,parent's pid=21352,returnid=0

       總結一下，這個程式執行的流程如下：

這個程式最終產生了3個子程序，執行過6次printf（）函式。

b)、接下來再看一段程式碼：

#include <unistd.h>
#include <stdio.h>
int main(void)
{
   int i=0;
   printf("i son/pa ppid pid  fpid\n");//ppid指當前程序的父程序pid，pid指當前程序的pid,fpid指fork返回給當前程序的值

   for(i=0;i<2;i++){
       pid_t fpid=fork();
        if(fpid<0)
                printf("error\n");
       if(fpid==0)
           printf("%d child  %4d %4d %4d\n",i,getppid(),getpid(),fpid);
       else
        {   printf("%d parent %4d %4d %4d\n",i,getppid(),getpid(),fpid);
}
   }
   return 0;
}

編譯執行結果如下：

[email protected]:~$ gcc -g fork1.c -o fork1 
[email protected]:~$ ./fork1
i son/pa ppid pid  fpid
0 parent 31055 29375 29376
0 child  29375 29376    0
1 parent 31055 29375 29377
1 parent 29375 29376 29378
1 child     1 29378    0
1 child     1 29377    0

該程式和上面的程式類似但是細心的讀者會發現，程序29378和程序29377的父程序難道不該是29376和29375嗎，怎麼會是1呢？在這裡得涉及到程序的建立和死亡過程，在29376和29375執行完第二個迴圈後，main函式就該退出了，也即程序該死亡了，因為它已經做完所有事情了。29376和29375死亡後，29378和29377就沒有父程序了就變成了孤兒程序，這在作業系統中是不被允許的，所以程序29378和程序29377的父程序就被置為1了，相當於把這兩個孤兒程序過繼給PID＝1的init程序（init程序是系統專用程序），是永遠不會死亡的。

我們在來看一份程式碼：

#include <unistd.h>
#include <stdio.h>
int main(void)
{
   int i=0;
   for(i=0;i<3;i++){
       pid_t fpid=fork();
       if(fpid==0)
    	   printf("son/n");
       else
    	   printf("father/n");
   }
   return 0;
}

編譯執行結果：

[email protected]:~$ gcc -g fork2.c -o fork2 
[email protected]:~$ ./fork2
father
son
father
father
father
father
son
son
son
father
son
father
son
son

針對上述結果進行一下詳細分析，如圖所示：

    總結一下規律，對於這種N次迴圈的情況，執行printf函式的次數為2*（1+2+4+……+2^N-1）次，建立的子程序數為1+2+4+……+2^N-1個。 網上有人說N次迴圈產生2*（1+2+4+……+2^N）個程序，這個說法是不對的，希望大家需要注意。

如果想測試一個程式中建立的子程序數，最好的方法就是呼叫printf函式列印該程序的pid，也即呼叫printf("%d \n",getpid());或者通過printf("+ \n");來判斷產生了幾個程序。有人想直接通過呼叫printf("+");來統計建立了幾個程序，這是不妥當的。具體原因如下：

我們重新來看一下本篇文章的第一段程式碼：

1）：我們編譯完之後執行結果如下：

[email protected]:~$ ./test1
a write to stdout
before fork
pid = 31332, glob = 7, var = 89
pid = 31331, glob = 6, var = 88

2）：接下來我們用第二種方式執行該程式，執行命令./test1 > tmp.out,然後cat tmp.out（./test1 > temp.out是將執行結果輸出到檔案tmp.out中；cat tmp.out是獲取該檔案的內容）得到結果如下：

w[email protected]:~$ ./test1 > tmp.out
[email protected]:~$ cat tmp.out 
a write to stdout
before fork
pid = 31335, glob = 7, var = 89
before fork
pid = 31334, glob = 6, var = 88

在第一種情況下：由於write函式是不帶緩衝的，因為在fork()之前呼叫的write,所以其資料寫到標準輸出一次。但是標準I/O庫是帶緩衝的，當我們用以上這種方式執行的時候，before fork只會輸出一次，其原因是我們是用的互動式方式執行的該程式，且標準輸出連到終端裝置，它是行緩衝，標準緩衝區由換行符沖洗掉了，所以只得到printf一次。

在第二種情況下我們得到兩次before fork：這是因為我們把標準輸出重定向到了tmp.out,它是全緩衝的，那麼該行資料不會被換行符沖洗掉，然後在將父程序的資料空間複製到子程序中時，該緩衝區也被複制到了子程序中。於是父子程序都擁有該行內容的標準I/O緩衝區。

進一步的解釋請看如下程式碼是：

#include <unistd.h>
#include <stdio.h>
int main() {
        pid_t fpid;//fpid表示fork函式返回的值
        //printf("fork!");
        //printf("fork!\n");
        fpid = fork();
        if (fpid < 0)
                printf("error in fork!");
        else if (fpid == 0)
                printf("I am the child process, my process id is %d\n", getpid());
        else
                printf("I am the parent process, my process id is %d\n", getpid());
        return 0;
}

註釋第一個printf輸出，保留第二個printf輸出的輸出結果：

[email protected]:~$ gcc -g fork3.c -o fork3
[email protected]:~$ ./fork3
fork!
I am the parent process, my process id is 31459
I am the child process, my process id is 31460

註釋第二個printf輸出，保留第一個printf輸出的輸出結果：

[email protected]:~$ gcc -g fork3.c -o fork3
[email protected]:~$ ./fork3
fork!I am the parent process, my process id is 31506
fork!I am the child process, my process id is 31507

分析：之所以會有上面的情況是跟printf的緩衝機制有關，即：printf某些內容時，作業系統僅僅是把該內容放到了stdout（標準輸出流）的緩衝佇列裡了,並沒有實際的寫到螢幕上。但是,只要看到有/n 則會立即重新整理stdout,因此就馬上能夠列印了。   運行了printf("fork!")後,“fork!”僅僅被放到了緩衝裡,程式執行到fork時，緩衝裡面的“fork!” 被子程序複製過去了。因此在子程序度stdout緩衝裡面就也有了fork! 。所以,你最終看到的會是fork!  被printf了2次！！！！
    而執行printf("fork! /n")後,“fork!”被立即列印到了螢幕上,之後fork到的子程序裡的stdout緩衝裡不會有fork! 內容（前面說過了子程序的執行不是從＃include開始執行的而是從程式碼段的fork處開始往下執行）。因此你看到的結果會是fork! 被printf了1次！！！！這就是為什麼說printf("+");不能正確地反應程序的數量的原因。

為了測試子程序是否複製了父程序緩衝區裡的內容，對本次文章第一次講解的程式碼作如下修改：

#include "apue.h"

int glob=6;
char buf[]="a write to stdout\n";

int main(void)
{
  int var;
  pid_t pid;
  var=88;
  if(write(STDOUT_FILENO,buf,sizeof(buf)-1)!=sizeof(buf)-1)
  err_sys("write error");
  printf("before fork %d\n",getpid());
  if((pid=fork())<0)
  err_sys("fork error");
  else if(pid==0)
  {
    glob++;
    var++;
  }
  else   sleep(2);
  printf("pid= %d,glod=%d, var=%d \n",getpid(),glob,var);
  exit(0);
}

編譯連線產生如下結果：

[email protected]:~$ gcc -g fork4.c -o fork4 libapue.a 
[email protected]:~$ ./fork4 >tmp.out
[email protected]:~$ cat tmp.out 
a write to stdout
before fork 1976
pid= 1977,glod=7, var=89 
before fork 1976
pid= 1976,glod=6, var=88

兩次輸出的都是before fork 1976,而1976是父程序的pid.所以可知子程序確實複製了父程序緩衝區中的內容。