fork函數詳解

時間  2019-11-26
標籤 fork 函數 詳解 欄目 Apache 简体版
原文   原文鏈接

 

1、fork入門知識html

     一個進程，包括代碼、數據和分配給進程的資源。fork（）函數經過系統調用建立一個與原來進程幾乎徹底相同的進程，也就是兩個進程能夠作徹底相同的事，但若是初始參數或者傳入的變量不一樣，兩個進程也能夠作不一樣的事。
    一個進程調用fork（）函數後，系統先給新的進程分配資源，例如存儲數據和代碼的空間。而後把原來的進程的全部值都複製到新的新進程中，只有少數值與原來的進程的值不一樣。至關於克隆了一個本身。linux

     咱們來看一個例子：緩存

/* 
 *  fork_test.c 
 *  version 1 
 *  Created on: 2010-5-29 
 *      Author: wangth 
 */  
#include <unistd.h>  
#include <stdio.h>   
int main ()   
{   
    pid_t fpid; //fpid表示fork函數返回的值  
    int count=0;  
    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());   
        printf("我是爹的兒子/n");//對某些人來講中文看着更直白。  
        count++;  
    }  
    else {  
        printf("i am the parent process, my process id is %d/n",getpid());   
        printf("我是孩子他爹/n");  
        count++;  
    }  
    printf("統計結果是: %d/n",count);  
    return 0;  
} 

運行結果是：
    i am the child process, my process id is 5574
    我是爹的兒子
    統計結果是: 1
    i am the parent process, my process id is 5573
    我是孩子他爹
    統計結果是: 1
    在語句fpid=fork()以前，只有一個進程在執行這段代碼，但在這條語句以後，就變成兩個進程在執行了，這兩個進程的幾乎徹底相同，將要執行的下一條語句都是if(fpid<0)……
    爲何兩個進程的fpid不一樣呢，這與fork函數的特性有關。fork調用的一個奇妙之處就是它僅僅被調用一次，卻可以返回兩次，它可能有三種不一樣的返回值：
    1）在父進程中，fork返回新建立子進程的進程ID；
    2）在子進程中，fork返回0；
    3）若是出現錯誤，fork返回一個負值；

    在fork函數執行完畢後，若是建立新進程成功，則出現兩個進程，一個是子進程，一個是父進程。在子進程中，fork函數返回0，在父進程中，fork返回新建立子進程的進程ID。咱們能夠經過fork返回的值來判斷當前進程是子進程仍是父進程。
    fork出錯可能有兩種緣由：
    1）當前的進程數已經達到了系統規定的上限，這時errno的值被設置爲EAGAIN。
    2）系統內存不足，這時errno的值被設置爲ENOMEM。
    建立新進程成功後，系統中出現兩個基本徹底相同的進程，這兩個進程執行沒有固定的前後順序，哪一個進程先執行要看系統的進程調度策略。
    每一個進程都有一個獨特（互不相同）的進程標識符（process ID），能夠經過getpid（）函數得到，還有一個記錄父進程pid的變量，能夠經過getppid（）函數得到變量的值。
    fork執行完畢後，出現兩個進程，

    執行完fork後，進程1的變量爲count=0，fpid！=0（父進程）。進程2的變量爲count=0，fpid=0（子進程），這兩個進程的變量都是獨立的，存在不一樣的地址中，不是共用的，這點要注意。能夠說，咱們就是經過fpid來識別和操做父子進程的。
    有人可能疑惑爲何不是從#include處開始複製代碼的，這是由於fork是把進程當前的狀況拷貝一份，執行fork時，進程已經執行完了int count=0;fork只拷貝下一個要執行的代碼到新的進程。
2、fork進階知識

    1.先看一份代碼：併發

/* 
 *  fork_test.c 
 *  version 2 
 *  Created on: 2010-5-29 
 *      Author: wangth 
 */  
#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("%d child  %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
       else  
           printf("%d parent %4d %4d %4d/n",i,getppid(),getpid(),fpid);  
   }  
   return 0;  
} 

運行結果是：
    i son/pa ppid pid  fpid
    0 parent 2043 3224 3225
    0 child  3224 3225    0
    1 parent 2043 3224 3226
    1 parent 3224 3225 3227
    1 child     1 3227    0
    1 child     1 3226    0
    這份代碼比較有意思，咱們來認真分析一下：
    第一步：在父進程中，指令執行到for循環中，i=0，接着執行fork，fork執行完後，系統中出現兩個進程，分別是p3224和p3225（後面我都用pxxxx表示進程id爲xxxx的進程）。能夠看到父進程p3224的父進程是p2043，子進程p3225的父進程正好是p3224。咱們用一個鏈表來表示這個關係：
    p2043->p3224->p3225
 第一次fork後，p3224（父進程）的變量爲i=0，fpid=3225（fork函數在父進程中返向子進程id），代碼內容爲：函數

for(i=0;i<2;i++){  
    pid_t fpid=fork();//執行完畢，i=0，fpid=3225  
    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;  

  p3225（子進程）的變量爲i=0，fpid=0（fork函數在子進程中返回0），代碼內容爲：測試

for(i=0;i<2;i++){  
    pid_t fpid=fork();//執行完畢，i=0，fpid=0  
    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;  

  因此打印出結果：
    0 parent 2043 3224 3225
    0 child  3224 3225    0
    第二步：假設父進程p3224先執行，當進入下一個循環時，i=1，接着執行fork，系統中又新增一個進程p3226，對於此時的父進程，p2043->p3224（當前進程）->p3226（被建立的子進程）。
    對於子進程p3225，執行完第一次循環後，i=1，接着執行fork，系統中新增一個進程p3227，對於此進程，p3224->p3225（當前進程）->p3227（被建立的子進程）。從輸出能夠看到p3225原來是p3224的子進程，如今變成p3227的父進程。父子是相對的，這個你們應該容易理解。只要當前進程執行了fork，該進程就變成了父進程了，就打印出了parent。
    因此打印出結果是：
    1 parent 2043 3224 3226
    1 parent 3224 3225 3227 
    第三步：第二步建立了兩個進程p3226，p3227，這兩個進程執行完printf函數後就結束了，由於這兩個進程沒法進入第三次循環，沒法fork，該執行return 0;了，其餘進程也是如此。
    如下是p3226，p3227打印出的結果：
    1 child     1 3227    0
    1 child     1 3226    0
    細心的讀者可能注意到p3226，p3227的父進程難道不應是p3224和p3225嗎，怎麼會是1呢？這裏得講到進程的建立和死亡的過程，在p3224和p3225執行完第二個循環後，main函數就該退出了，也即進程該死亡了，由於它已經作完全部事情了。p3224和p3225死亡後，p3226，p3227就沒有父進程了，這在操做系統是不被容許的，因此p3226，p3227的父進程就被置爲p1了，p1是永遠不會死亡的，至於爲何，這裏先不介紹，留到「3、fork高階知識」講。
    總結一下，這個程序執行的流程以下：
spa

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

2.咱們再來看一份代碼：操作系統

/* 
 *  fork_test.c 
 *  version 3 
 *  Created on: 2010-5-29 
 *      Author: wangth 
 */  
#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;  
  
}  

它的執行結果是：
    father
    son
    father
    father
    father
    father
    son
    son
    father
    son
    son
    son
    father
    son
    這裏就不作詳細解釋了，只作一個大概的分析。
    for        i=0         1           2
              father     father     father
                                        son
                            son       father
                                        son
               son       father     father
                                        son
                            son       father
                                        son
    其中每一行分別表明一個進程的運行打印結果。
    總結一下規律，對於這種N次循環的狀況，執行printf函數的次數爲2*（1+2+4+……+2N-1）次，建立的子進程數爲1+2+4+……+2N-1個。.net

3.最後，對printf的緩衝機制作一個簡單分析，代碼以下：unix

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
 
int main()
{
    pid_t pid;
    
    printf("parent\n");
    pid = fork();
    if (0 == pid)
    {
        printf("child\n");
    }
    else if (pid > 0)
    {
        printf("parent\n");
    }
    else if (pid < 0)
    {
        printf("error\n");
    }        
    return 0;
}

輸出結果爲：
parent
parent
child

我把第一個printf裏的'\n'去掉後，測試的輸出結果是：

parentparent
parentchild

爲何兩種狀況的輸出結果差一個parent呢，由於prient函數存在緩衝機制，在詳細介紹以前，先對緩衝作簡要了解：

緩衝區又稱爲緩存，它是內存空間的一部分。也就是說，在內存空間中預留了必定的存儲空間，這些存儲空間用來緩衝輸入或輸出的數據，這部分預留的空間就叫作緩衝區。

緩衝區根據其對應的是輸入設備仍是輸出設備，分爲輸入緩衝區和輸出緩衝區。

爲何要引入緩衝區

好比咱們從磁盤裏取信息，咱們先把讀出的數據放在緩衝區，計算機再直接從緩衝區中取數據，等緩衝區的數據取完後再去磁盤中讀取，這樣就能夠減小磁盤的讀寫次數，再加上計算機對緩衝區的操做大大快於對磁盤的操做，故應用緩衝區可大大提升計算機的運行速度。

又好比，咱們使用打印機打印文檔，因爲打印機的打印速度相對較慢，咱們先把文檔輸出到打印機相應的緩衝區，打印機再自行逐步打印，這時咱們的CPU能夠處理別的事情。

如今您基本明白了吧，緩衝區就是一塊內存區，它用在輸入輸出設備和CPU之間，用來緩存數據。它使得低速的輸入輸出設備和高速的CPU可以協調工做，避免低速的輸入輸出設備佔用CPU，解放出CPU，使其可以高效率工做。

緩衝區的類型

緩衝區 分爲三種類型：全緩衝、行緩衝和不帶緩衝。

1) 全緩衝

在這種狀況下，當填滿標準I/O緩存後才進行實際I/O操做。全緩衝的典型表明是對磁盤文件的讀寫。

2) 行緩衝

在這種狀況下，當在輸入和輸出中遇到換行符時，執行真正的I/O操做。這時，咱們輸入的字符先存放在緩衝區，等按下回車鍵換行時才進行實際的I/O操做。典型表明是標準輸入(stdin)和標準輸出(stdout)。

3) 不帶緩衝

也就是不進行緩衝，標準出錯狀況stderr是典型表明，這使得出錯信息能夠直接儘快地顯示出來。

 

由此可知，由於printf函數其實調用的是全局宏stdout（標準輸出），因此printf的緩衝屬於行緩衝。

那什麼狀況下會刷新緩衝區?

  • 程序結束時調用 exit(0) .
  • 遇到 \n , \r 時會刷新緩衝區.
  • 手動刷新 fflush .
  • 緩衝區滿時自動刷新.

咱們知道了以上內容後，回到剛纔的代碼

printf函數在執行輸出內容時，操做系統僅僅是把該內容放到了stdout的緩衝隊列裏，並無實際的寫到屏幕上。可是,只要看到有\n 則會當即刷新stdout，所以就立刻可以打印了。 

運行了printf("parent")後，「parent」僅僅被放到了緩衝裏，程序運行到fork()時緩衝裏面的「parent」 被子進程複製過去了。所以在子進程度stdout緩衝裏面就也有了parent。因此，最終看到的會是parent 被printf了2次。

而運行printf("parent/n")後,，parent被當即打印到了屏幕上，以後fork()的子進程裏的stdout緩衝裏不會有「parent」。所以最終看到的結果parent只被printf了1次。

fork（）會產生一個和父進程徹底相同的子進程，但子進程在此後多會exec系統調用，出於效率考慮，linux中引入了「寫時複製「技術，也就是隻有進程空間的各段的內容要發生變化時，纔會將父進程的內容複製一份給子進程。在fork以後exec以前兩個進程用的是相同的物理空間（內存區），子進程的代碼段、數據段、堆棧都是指向父進程的物理空間，也就是說，二者的虛擬空間不一樣，但其對應的物理空間是同一個。當父子進程中有更改相應段的行爲發生時，再爲子進程相應的段分配物理空間，若是沒有exec，內核會給子進程的數據段、堆棧段分配相應的物理空間（至此二者有各自的進程空間，互不影響），而代碼段繼續共享父進程的物理空間（二者的代碼徹底相同）。而若是是由於exec，因爲二者執行的代碼不一樣，子進程的代碼段也會分配單獨的物理空間。

fork時子進程得到父進程數據空間、堆和棧的複製，因此變量的地址（固然是虛擬地址）也是同樣的。

每一個進程都有本身的虛擬地址空間，不一樣進程的相同的虛擬地址顯然能夠對應不一樣的物理地址。所以地址相同（虛擬地址）而值不一樣沒什麼奇怪。 具體過程是這樣的： fork子進程徹底複製父進程的棧空間，也複製了頁表，但沒有複製物理頁面，因此這時虛擬地址相同，物理地址也相同，可是會把父子共享的頁面標記爲「只讀」（相似mmap的private的方式），若是父子進程一直對這個頁面是同一個頁面，知道其中任何一個進程要對共享的頁面「寫操做」，這時內核會複製一個物理頁面給這個進程使用，同時修改頁表。而把原來的只讀頁面標記爲「可寫」，留給另一個進程使用。


這就是所謂的「寫時複製」。正由於fork採用了這種寫時複製的機制，因此fork出來子進程以後，父子進程哪一個先調度呢？內核通常會先調度子進程，由於不少狀況下子進程是要立刻執行exec，會清空棧、堆。。這些和父進程共享的空間，加載新的代碼段。。。，這就避免了「寫時複製」拷貝共享頁面的機會。若是父進程先調度極可能寫共享頁面，會產生「寫時複製」的無用功。因此，通常是子進程先調度滴。

假定父進程malloc的指針指向0x12345678, fork 後，子進程中的指針也是指向0x12345678，可是這兩個地址都是虛擬內存地址 （virtual memory)，通過內存地址轉換後所對應的 物理地址是不同的。因此兩個進城中的這兩個地址相互之間沒有任何關係。

（注1：在理解時，你能夠認爲fork後，這兩個相同的虛擬地址指向的是不一樣的物理地址，這樣方便理解父子進程之間的獨立性） （注2：但實際上，linux爲了提升 fork 的效率，採用了 copy-on-write 技術，fork後，這兩個虛擬地址實際上指向相同的物理地址（內存頁），只有任何一個進程試圖修改這個虛擬地址裏的內容前，兩個虛擬地址纔會指向不一樣的物理地址（新的物理地址的內容從原物理地址中複製獲得））

4.

*********父進程爲何要建立子進程呢?*************

前面咱們已經說過了Linux是一個多用戶操做系統,在同一時間會有許多的用戶在爭奪系統的資源.有時進程爲了早一點完成任務就建立子進程來爭奪資源. 一旦子進程被建立,父子進程一塊兒從fork處繼續執行,相互競爭系統的資源.有時候咱們但願子進程繼續執行,而父進程阻塞,直到子進程完成任務.這個時候咱們能夠調用wait或者waitpid系統調用.

,對子進程來講，fork返回給它0,但它的pid絕對不會是0；之因此fork返回0給它，是由於它隨時能夠調用getpid()來獲取本身的pid；

fork以後父子進程除非採用了同步手段，不然不能肯定誰先運行，也不能肯定誰先結束。認爲子進程結束後父進程才從fork返回的，這是不對的，fork不是這樣的，vfork才這樣。

*****************************************爲何返回0呢**************************************************

首先必須有一點要清楚，函數的返回值是儲存在寄存器eax中的。
其次，當fork返回時，新進程會返回0是由於在初始化任務結構時，將eax設置爲0；
在fork中，把子進程加入到可運行的隊列中，由進程調度程序在適當的時機調度運行。也就是今後時開始，當前進程分裂爲兩個併發的進程。
不管哪一個進程被調度運行，都將繼續執行fork函數的剩餘代碼，執行結束後返回各自的值。

***********************************************fork()以後的寄存器具體執行*************************************

【NOTE5】
對於fork來講，父子進程共享同一段代碼空間，因此給人的感受好像是有兩次返回，其實對於調用fork的父進程來講，若是fork出來的子進程沒有獲得調度，那麼父進程從fork系統調用返回，同時分析sys_fork知道，fork返回的是子進程的id。再看fork出來的子進程，由 copy_process函數能夠看出，子進程的返回地址爲ret_from_fork（和父進程在同一個代碼點上返回），返回值直接置爲0。因此當子進程獲得調度的時候，也從fork返回，返回值爲0。
關鍵注意兩點：

1.fork返回後，父進程或子進程的執行位置。（首先會將當前進程eax的值作爲返回值）

2.兩次返回的pid存放的位置。（eax中）


進程調用copy_process獲得lastpid的值（放入eax中，fork正常返回後，父進程中返回的就是lastpid）
子進程任務狀態段tss的eax被設置成0，
fork.c 中
p-&gt;tss.eax=0;（若是子進程要執行就須要進程切換，當發生切換時，子進程tss中的eax值就調入eax寄存器，子進程執行時首先會將eax的內容作爲返回值）
當子進程開始執行時，copy_process返回eax的值。
fork()後,就是兩個任務同時進行,父進程用他的tss,子進程用本身的tss,在切換時,各用各的eax中的值.
因此，「一次調用兩次返回」是2個不一樣的進程！
看這一句：pid＝fork()
當執行這一句時，當前進程進入fork()運行，此時，fork()內會用一段嵌入式彙編進行系統調用：int 0x80（具體代碼可參見內核版本0.11的unistd.h文件的133行_syscall0函數）。這時進入內核根據此前寫入eax的系統調用功能號便會運行sys_fork系統調用。接着，sys_fork中首先會調用C函數find_empty_process產生一個新的進程，而後會調用C函數 copy_process將父進程的內容複製給子進程，可是子進程tss中的eax值賦值爲0（這也是爲何子進程中返回0的緣由），當賦值完成後， copy_process會返回新進程（該子進程）的pid，這個值會被保存到eax中。這時子進程就產生了，此時子進程與父進程擁有相同的代碼空間，程序指針寄存器eip指向相同的下一條指令地址，當fork正常返回調用其的父進程後，由於eax中的值是新建立的子進程號，因此，fork()返回子進程號，執行else（pid&gt;0）;當產生進程切換運行子進程時，首先會恢復子進程的運行環境即裝入子進程的tss任務狀態段，其中的eax 值(copy_process中置爲0)也會被裝入eax寄存器，因此，當子進程運行時，fork返回的是0執行if(pid==0)。



參考：

　　https://blog.csdn.net/jason314/article/details/5640969?utm_source=copy

　　http://blog.csdn.net/dog_in_yellow/archive/2008/01/13/2041079.aspx

　　http://blog.chinaunix.net/u1/53053/showart_425189.html

　　http://blog.csdn.net/saturnbj/archive/2009/06/19/4282639.aspx

　　http://www.cppblog.com/zhangxu/archive/2007/12/02/37640.html

　　http://www.qqread.com/linux/2010/03/y491043.html

　　http://www.yuanma.org/data/2009/1103/article_3998.htm

　　https://www.jb51.net/article/127400.htm

　　https://blog.csdn.net/xy010902100449/article/details/44851453

　　https://blog.csdn.net/shenwansangz/article/details/39184789

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程