fork，vfork，clone
Unix標準的復制進程的系統(tǒng)調(diào)用時fork（即分叉），但是Linux，BSD等操作系統(tǒng)并不止實現(xiàn)這一個，確切的說linux實現(xiàn)了三個，fork,vfork,clone（確切說vfork創(chuàng)造出來的是輕量級進程，也叫線程，是共享資源的進程）
系統(tǒng)調(diào)用
描述
fork
fork創(chuàng)造的子進程是父進程的完整副本，復制了父親進程的資源，包括內(nèi)存的內(nèi)容task_struct內(nèi)容
vfork
vfork創(chuàng)建的子進程與父進程共享數(shù)據(jù)段,而且由vfork()創(chuàng)建的子進程將先于父進程運行
clone
Linux上創(chuàng)建線程一般使用的是pthread庫 實際上linux也給我們提供了創(chuàng)建線程的系統(tǒng)調(diào)用，就是clone
fork
include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main(void){ int count = 1; int child; child = fork( ); if(child < 0) { perror("fork error : "); } else if(child == 0) // fork return 0 in the child process because child can get hid PID by getpid( ) { printf("This is son, his count is: %d (%p). and his pid is: %d\n", ++count, &count, getpid()); } else // the PID of the child process is returned in the parent’s thread of execution { printf("This is father, his count is: %d (%p), his pid is: %d\n", count, &count, getpid()); } return EXIT_SUCCESS;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
從運行結(jié)果里面可以看出父子兩個進程的pid不同，堆棧和數(shù)據(jù)資源都是完全的復制
子進程改變了count的值，而父進程中的count沒有被改變。
子進程與父進程count的地址（虛擬地址）是相同的（注意他們在內(nèi)核中被映射的物理地址不同）
寫時復制
有人認為這樣大批量的復制會導致執(zhí)行效率過低。其實在復制過程中，linux采用了寫時復制的策略。
子進程復制了父進程的task_struct，系統(tǒng)堆棧空間和頁面表，這意味著上面的程序，我們沒有執(zhí)行count++前，其實子進程和父進程的count指向的是同一塊內(nèi)存。而當子進程改變了變量時候（即對變量進行了寫操作），會通過copy_on_write的手段為所涉及的頁面建立一個新的副本。
所以當我們執(zhí)行++count后，這時候子進程才新建了一個頁面復制原來頁面的內(nèi)容，基本資源的復制是必須的，而且是高效的。整體看上去就像是父進程的獨立存儲空間也復制了一遍。
寫入時復制(Copy-on-write)是一個被使用在程式設計領域的最佳化策略。其基礎的觀念是，如果有多個呼叫者(callers)同時要求相同資源，他們會共同取得相同的指標指向相同的資源，直到某個呼叫者(caller)嘗試修改資源時，系統(tǒng)才會真正復制一個副本(private copy)給該呼叫者，以避免被修改的資源被直接察覺到，這過程對其他的呼叫只都是通透的(transparently)。此作法主要的優(yōu)點是如果呼叫者并沒有修改該資源，就不會有副本(private copy)被建立。
第一代Unix系統(tǒng)實現(xiàn)了一種傻瓜式的進程創(chuàng)建：當發(fā)出fork()系統(tǒng)調(diào)用時，內(nèi)核原樣復制父進程的整個地址空間并把復制的那一份分配給子進程。這種行為是非常耗時的，因為它需要：
為子進程的頁表分配頁幀
為子進程的頁分配頁幀
初始化子進程的頁表
把父進程的頁復制到子進程相應的頁中
這種創(chuàng)建地址空間的方法涉及許多內(nèi)存訪問，消耗許多CPU周期，并且完全破壞了高速緩存中的內(nèi)容。在大多數(shù)情況下，這樣做常常是毫無意義的，因為許多子進程通過裝入一個新的程序開始它們的執(zhí)行，這樣就完全丟棄了所繼承的地址空間。
現(xiàn)在的Linux內(nèi)核采用一種更為有效的方法，稱之為寫時復制（Copy On Write，COW）。這種思想相當簡單：父進程和子進程共享頁幀而不是復制頁幀。然而，只要頁幀被共享，它們就不能被修改，即頁幀被保護。無論父進程還是子進程何時試圖寫一個共享的頁幀，就產(chǎn)生一個異常，這時內(nèi)核就把這個頁復制到一個新的頁幀中并標記為可寫。原來的頁幀仍然是寫保護的：當其他進程試圖寫入時，內(nèi)核檢查寫進程是否是這個頁幀的唯一屬主，如果是，就把這個頁幀標記為對這個進程是可寫的。
當進程A使用系統(tǒng)調(diào)用fork創(chuàng)建一個子進程B時,由于子進程B實際上是父進程A的一個拷貝,
因此會擁有與父進程相同的物理頁面.為了節(jié)約內(nèi)存和加快創(chuàng)建速度的目標,fork()函數(shù)會讓子進程B以只讀方式共享父進程A的物理頁面.同時將父進程A對這些物理頁面的訪問權(quán)限也設成只讀.
這樣,當父進程A或子進程B任何一方對這些已共享的物理頁面執(zhí)行寫操作時,都會產(chǎn)生頁面出錯異常(page_fault int14)中斷,此時CPU會執(zhí)行系統(tǒng)提供的異常處理函數(shù)do_wp_page()來解決這個異常.
do_wp_page()會對這塊導致寫入異常中斷的物理頁面進行取消共享操作,為寫進程復制一新的物理頁面,使父進程A和子進程B各自擁有一塊內(nèi)容相同的物理頁面.最后,從異常處理函數(shù)中返回時,CPU就會重新執(zhí)行剛才導致異常的寫入操作指令,使進程繼續(xù)執(zhí)行下去.
vfork
如果fork簡單的vfork()的做法更加火爆，內(nèi)核連子進程的虛擬地址空間結(jié)構(gòu)也不創(chuàng)建了，直接共享了父進程的虛擬空間，當然了，這種做法就順水推舟的共享了父進程的物理空間
include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main(void){ int count = 1; int child; // child = vfork( ); printf("Before create son, the father's count is:%d\n", count); if((child = vfork())< 0) { perror("fork error : "); } else if(child == 0) // fork return 0 in the child process because child can get hid PID by getpid( ) { printf("This is son, his count is: %d (%p). and his pid is: %d\n", ++count, &count, getpid()); exit(0); } else // the PID of the child process is returned in the parent’s thread of execution { printf("After son, This is father, his count is: %d (%p), his pid is: %d\n", ++count, &count, getpid()); exit(0); } return EXIT_SUCCESS;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
從運行結(jié)果可以看到vfork創(chuàng)建出的子進程（線程）共享了父進程的count變量，2者的count指向了同一個內(nèi)存，所以子進程修改了count變量，父進程的 count變量同樣受到了影響。
參見 man-vfork(2)
由vfork創(chuàng)造出來的子進程還會導致父進程掛起，除非子進程exit或者execve才會喚起父進程
由vfok創(chuàng)建出來的子進程共享了父進程的所有內(nèi)存，包括棧地址，直至子進程使用execve啟動新的應用程序為止
由vfork創(chuàng)建出來得子進程不應該使用return返回調(diào)用者，或者使用exit()退出，但是它可以使用_exit()函數(shù)來退出
如果我們使用return來退出，你會發(fā)現(xiàn)程序陷入一種邏輯混亂的重復vfork狀態(tài)
參見下面的代碼
include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>int main(void){ int count = 1; int child; // child = vfork( ); printf("Before create son, the father's count is : %d\n", count); if((child = vfork())< 0) { perror("fork error : "); } else if(child == 0) // fork return 0 in the child process because child can get hid PID by getpid( ) { printf("This is son, his count is: %d (%p). and his pid is: %d\n", ++count, &count, getpid()); } else // the PID of the child process is returned in the parent’s thread of execution { printf("After son, This is father, his count is: %d (%p), his pid is: %d\n", count, &count, getpid()); sleep(2); } return EXIT_SUCCESS;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
我們會發(fā)現(xiàn)vfork的子進程在使用return后，返回到了調(diào)用處，因此父進程又創(chuàng)建出一個新的vfork進程，
解決這種問題的方法就是不要在進程中使用return，而是使用exit或者_exit來代替
fork與vfork
區(qū)別與聯(lián)系
vfork()用法與fork()相似.但是也有區(qū)別,具體區(qū)別歸結(jié)為以下3點
fork() 子進程拷貝父進程的數(shù)據(jù)段，代碼段. vfork() 子進程與父進程共享數(shù)據(jù)段.|
fork() 父子進程的執(zhí)行次序不確定. vfork():保證子進程先運行，
vfork()保證子進程先運行，在她調(diào)用exec或_exit之后父進程才可能被調(diào)度運行。如果在 調(diào)用這兩個函數(shù)之前子進程依賴于父進程的進一步動作，則會導致死鎖。
在調(diào)用exec或_exit之前與父進程數(shù)據(jù)是共享的,在它調(diào)用exec或_exit之后父進程才可能被調(diào)度運行。如果在調(diào)用這兩個函數(shù)之前子進程依賴于父進程的進一步動作，則會導致死鎖。當需要改變共享數(shù)據(jù)段中變量的值，則拷貝父進程
vfork用于創(chuàng)建一個新進程，而該新進程的目的是exec一個新進程，vfork和fork一樣都創(chuàng)建一個子進程，但是它并不將父進程的地址空間完全復制到子進程中，不會復制頁表。因為子進程會立即調(diào)用exec，于是也就不會存放該地址空間。不過在子進程中調(diào)用exec或exit之前，他在父進程的空間中運行。
如果在調(diào)用vfork時子進程依賴于父進程的進一步動作，則會導致死鎖。由此可見，這個系統(tǒng)調(diào)用是用來啟動一個新的應用程序。其次，子進程在vfork()返回后直接運行在父進程的棧空間，并使用父進程的內(nèi)存和數(shù)據(jù)。這意味著子進程可能破壞父進程的數(shù)據(jù)結(jié)構(gòu)或棧，造成失敗。
為了避免這些問題，需要確保一旦調(diào)用vfork()，子進程就不從當前的棧框架中返回，并且如果子進程改變了父進程的數(shù)據(jù)結(jié)構(gòu)就不能調(diào)用exit函數(shù)。
子進程還必須避免改變?nèi)謹?shù)據(jù)結(jié)構(gòu)或全局變量中的任何信息，因為這些改變都有可能使父進程不能繼續(xù)。通常，如果應用程序不是在fork()之后立即調(diào)用exec()，就有必要在fork()被替換成vfork()之前做仔細的檢查。
為什么會有vfork
因為以前的fork當它創(chuàng)建一個子進程時，將會創(chuàng)建一個新的地址空間，并且拷貝父進程的資源，而往往在子進程中會執(zhí)行exec調(diào)用，這樣，前面的拷貝工作就是白費力氣了，這種情況下，聰明的人就想出了vfork，它產(chǎn)生的子進程剛開始暫時與父進程共享地址空間（其實就是線程的概念了），因為這時候子進程在父進程的地址空間中運行，所以子進程不能進行寫操作，
并且在兒子“霸占”著老子的房子時候，要委屈老子一下了，讓他在外面歇著（阻塞），一旦兒子執(zhí)行了exec或者exit后，相當于兒子買了自己的房子了，這時候就相當于分家了。此時vfork保證子進程先運行，在她調(diào)用exec或exit之后父進程才可能被調(diào)度運行。
因此vfork設計用以子進程創(chuàng)建后立即執(zhí)行execve系統(tǒng)調(diào)用加載新程序的情形。在子進程退出或開始新程序之前，內(nèi)核保證了父進程處于阻塞狀態(tài)
用vfork函數(shù)創(chuàng)建子進程后，子進程往往要調(diào)用一種exec函數(shù)以執(zhí)行另一個程序，當進程調(diào)用一種exec函數(shù)時，該進程完全由新程序代換，而新程序則從其main函數(shù)開始執(zhí)行，因為調(diào)用exec并不創(chuàng)建新進程，所以前后的進程id 并未改變，exec只是用另一個新程序替換了當前進程的正文，數(shù)據(jù)，堆和棧段。
clone
參見
man手冊
clone函數(shù)功能強大，帶了眾多參數(shù)，因此由他創(chuàng)建的進程要比前面2種方法要復雜。
clone可以讓你有選擇性的繼承父進程的資源，你可以選擇想vfork一樣和父進程共享一個虛存空間，從而使創(chuàng)造的是線程，你也可以不和父進程共享，你甚至可以選擇創(chuàng)造出來的進程和父進程不再是父子關系，而是兄弟關系。
先有必要說下這個函數(shù)的結(jié)構(gòu) ···c int clone(int (*fn)(void *), void *child_stack, int flags, void *arg); ···
這里fn是函數(shù)指針，我們知道進程的4要素，這個就是指向程序的指針，就是所謂的“劇本”, child_stack明顯是為子進程分配系統(tǒng)堆棧空間（在linux下系統(tǒng)堆棧空間是2頁面，就是8K的內(nèi)存，其中在這塊內(nèi)存中，低地址上放入了值，這個值就是進程控制塊task_struct的值）,flags就是標志用來描述你需要從父進程繼承那些資源， arg就是傳給子進程的參數(shù)）。下面是flags可以取的值
標志
含義
CLONE_PARENT
創(chuàng)建的子進程的父進程是調(diào)用者的父進程，新進程與創(chuàng)建它的進程成了“兄弟”而不是“父子”
CLONE_FS
子進程與父進程共享相同的文件系統(tǒng)，包括root、當前目錄、umask
CLONE_FILES
子進程與父進程共享相同的文件描述符（file descriptor）表
CLONE_NEWNS
在新的namespace啟動子進程，namespace描述了進程的文件hierarchy
CLONE_SIGHAND
子進程與父進程共享相同的信號處理（signal handler）表
CLONE_PTRACE
若父進程被trace，子進程也被trace
CLONE_VFORK
父進程被掛起，直至子進程釋放虛擬內(nèi)存資源
CLONE_VM
子進程與父進程運行于相同的內(nèi)存空間
CLONE_PID
子進程在創(chuàng)建時PID與父進程一致
CLONE_THREAD
Linux 2.4中增加以支持POSIX線程標準，子進程與父進程共享相同的線程群
下面的例子是創(chuàng)建一個線程（子進程共享了父進程虛存空間，沒有自己獨立的虛存空間不能稱其為進程）。父進程被掛起當子線程釋放虛存資源后再繼續(xù)執(zhí)行。
include <stdio.h>#include <malloc.h>#include <sched.h>#include <signal.h>#include <sys/types.h>#include <unistd.h>#define FIBER_STACK 8192int a;void * stack;int do_something(){ printf("This is son, the pid is:%d, the a is: %d\n", getpid(), ++a); free(stack); //這里我也不清楚，如果這里不釋放，不知道子線程死亡后，該內(nèi)存是否會釋放，知情者可以告訴下,謝謝 exit(1);}int main(){ void * stack; a = 1; stack = malloc(FIBER_STACK);//為子進程申請系統(tǒng)堆棧 if(!stack) { printf("The stack failed\n"); exit(0); } printf("creating son thread!!!\n"); clone(&do_something, (char *)stack + FIBER_STACK, CLONE_VM|CLONE_VFORK, 0);//創(chuàng)建子線程 printf("This is father, my pid is: %d, the a is: %d\n", getpid(), a); exit(1);}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
clone, fork, vfork區(qū)別與聯(lián)系
實現(xiàn)參見
實現(xiàn)方式思路
系統(tǒng)調(diào)用服務例程sys_clone, sys_fork, sys_vfork三者最終都是調(diào)用do_fork函數(shù)完成.
do_fork的參數(shù)與clone系統(tǒng)調(diào)用的參數(shù)類似, 不過多了一個regs(內(nèi)核棧保存的用戶模式寄存器). 實際上其他的參數(shù)也都是用regs取的
具體實現(xiàn)的參數(shù)不同
clone: clone的API外衣, 把fn, arg壓入用戶棧中, 然后引發(fā)系統(tǒng)調(diào)用. 返回用戶模式后下一條指令就是fn. sysclone: parent_tidptr, child_tidptr都傳到了 do_fork的參數(shù)中 sysclone: 檢查是否有新的棧, 如果沒有就用父進程的棧 (開始地址就是regs.esp)
fork, vfork: 服務例程就是直接調(diào)用do_fork, 不過參數(shù)稍加修改 clone_flags: sys_fork: SIGCHLD, 0, 0, NULL, NULL, 0 sys_vfork: CLONE_VFORK | CLONE_VM | SIGCHLD, 0, 0, NULL, NULL, 0 用戶棧: 都是父進程的棧. parent_tidptr, child_ctidptr都是NULL.
