linux下C 程式設計學習之多程序程式設計（一）
一、程序概念
程序是作業系統中資源分配的最小單位，而執行緒是排程的最小單位。
一個程序，主要包含三個元素：
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
我們在來看一份程式碼：
#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+……+2N-1）次，建立的子程序數為1+2+4+……+2N-1個。 網上有人說N次迴圈產生2*（1+2+4+……+2N）個程序，這個說法是不對的，希望大家需要注意。
如果想測試一個程式中建立的子程序數，最好的方法就是呼叫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