fork（）與vfock（）都是建立一個程序，那他們有什麼區別呢？總結有以下三點區別： 
1.  fork  （）：子程序拷貝父程序的資料段，程式碼段 
    vfork （ ）：子程序與父程序共享資料段 
2.  fork （）父子程序的執行次序不確定 
    vfork 保證子程序先執行，在呼叫exec 或exit 之前與父程序資料是共享的,在它呼叫exec
     或exit 之後父程序才可能被排程執行。 
3.  vfork （）保證子程序先執行，在她呼叫exec 或exit 之後父程序才可能被排程執行。如果在
   呼叫這兩個函式之前子程序依賴於父程序的進一步動作，則會導致死鎖。 

下面通過幾個例子加以說明： 
第一：子程序拷貝父程序的程式碼段的例子： 

1. #include<sys/types.h>
2. #include<unistd.h>
3. #include<stdio.h>
4. int main()  
5. {  
6.     pid_t pid;  
7.     pid = fork();  
8.     if(pid<0)  
9.         printf("error in fork!\n");  
10.     elseif(pid == 0)  
11.         printf("I am the child process,ID is %d\n",getpid());  
12.     else
13.         printf("I am the parent process,ID is %d\n",getpid());  
14.     return 0;  
15. }  

執行結果： 

1. [[email protected] fork]# gcc -o fork fork.c   
2. [[email protected] fork]# ./fork  

1. I am the child process,ID is 4711  
2. I am the parent process,ID is 4710  

為什麼兩條語 都會列印呢？這是因為fork（）函式用於從已存在的程序中建立一個新的進 
程，新的程序稱為子程序，而原程序稱為父程序，fork （）的返回值有兩個，子程序返回0，

父程序返回子程序的程序號，程序號都是非零的正整數，所以父程序返回的值一定大於零，
在pid=fork();語句之前只有父程序在執行，而在pid=fork();之後，父程序和新建立的子程序 
都在執行，所以如果pid==0，那麼肯定是子程序，若pid ！=0 （事實上肯定大於0），那麼是 
父程序在執行。而我們知道fork()函式子程序是拷貝父程序的程式碼段的，所以子程序中同樣 
有 
if(pid<0) 
         printf("error in fork!"); 
     else if(pid==0) 
         printf("I am the child process,ID is %d\n",getpid()); 
     else 
         printf("I am the parent process,ID is %d\n",getpid()); 
} 
這麼一段程式碼，所以上面這段程式碼會被父程序和子程序各執行一次，最終由於子程序的pid= =0,

而打印出第一句話，父程序的pid>0，而打印出第二句話。於是得到了上面的執行結果。 
再來看一個拷貝資料段的例子： 

1. #include<sys/types.h>
2. #include<unistd.h>
3. #include<stdio.h>
4. int main()  
5. {  
6.     pid_t pid;  
7.     int cnt = 0;  
8.     pid = fork();  
9.     if(pid<0)  
10.         printf("error in fork!\n");  
11.     elseif(pid == 0)  
12.     {  
13.         cnt++;  
14.         printf("cnt=%d\n",cnt);  
15.         printf("I am the child process,ID is %d\n",getpid());  
16.     }  
17.     else
18.     {  
19.         cnt++;  
20.         printf("cnt=%d\n",cnt);  
21.         printf("I am the parent process,ID is %d\n",getpid());  
22.     }  
23.     return 0;  
24. }  

大家覺著打印出的值應該是多少呢？是不是2 呢？先來看下執行結果吧 

1. [[email protected] fork]# ./fork2  
2. cnt=1  
3. I am the child process,ID is 5077  
4. cnt=1  
5. I am the parent process,ID is 5076  

為什麼不是2 呢？因為我們一次強調fork （）函式子程序拷貝父程序的資料段程式碼段，所以 
cnt++; 
    printf("cnt= %d\n",cnt);

    return 0 
將被父子程序各執行一次，但是子程序執行時使自己的資料段裡面的（這個資料段是從父進 
程那copy 過來的一模一樣）count+1，同樣父程序執行時使自己的資料段裡面的count+1， 
他們互不影響，與是便出現瞭如上的結果。

那麼再來看看vfork （）吧。如果將上面程式中的fork （）改成vfork（），執行結果是什麼 
樣子的呢？ 

1. [[email protected] fork]# gcc -o fork3 fork3.c   
2. [[email protected] fork]# ./fork3  
3. cnt=1  
4. I am the child process,ID is 4711  
5. cnt=1  
6. I am the parent process,ID is 4710  
7. 段錯誤  

本來vfock（）是共享資料段的，結果應該是2，為什麼不是預想的2 呢？先看一個知識點： 
vfork 和fork 之間的另一個區別是：vfork 保證子程序先執行，在她呼叫exec 或exit 之 
後父程序才可能被排程執行。如果在呼叫這兩個函式之前子程序依賴於父程序的進一步動 
作，則會導致死鎖。 
這樣上面程式中的fork （）改成vfork（）後，vfork （）建立子程序並沒有呼叫exec 或exit，
所以最終將導致死鎖。 
怎麼改呢？看下面程式： 

1. #include<sys/types.h>
2. #include<unistd.h>
3. #include<stdio.h>
4. int main()  
5. {  
6.     pid_t pid;  
7.     int cnt = 0;  
8.     pid = vfork();  
9.     if(pid<0)  
10.         printf("error in fork!\n");  
11.     elseif(pid == 0)  
12.     {  
13.         cnt++;  
14.         printf("cnt=%d\n",cnt);  
15.         printf("I am the child process,ID is %d\n",getpid());  
16.        _exit(0);  
17.     }  
18.     else
19.     {  
20.         cnt++;  
21.         printf("cnt=%d\n",cnt);  
22.         printf("I am the parent process,ID is %d\n",getpid());  
23.     }  
24.     return 0;  
25. }  

如果沒有_exit（0）的話，子程序沒有呼叫exec 或exit，所以父程序是不可能執行的，在子 
程序呼叫exec 或exit 之後父程序才可能被排程執行。 
所以我們加上_exit(0);使得子程序退出，父程序執行，這樣else 後的語句就會被父程序執行， 
又因在子程序呼叫exec 或exit之前與父程序資料是共享的,所以子程序退出後把父程序的數 
據段count改成1 了，子程序退出後，父程序又執行，最終就將count變成了2，看下實際 
執行結果： 

1. [[email protected]ocalhost fork]# gcc -o fork3 fork3.c   
2. [[email protected] fork]# ./fork3  
3. cnt=1  
4. I am the child process,ID is 4711  
5. cnt=2  
6. I am the parent process,ID is 4710  

網上抄的一段，可以再理解理解： 
為什麼會有vfork，因為以前的fork 很傻， 它建立一個子程序時，將會建立一個新的地址 
空間，並且拷貝父程序的資源，而往往在子程序中會執行exec 呼叫，這樣，前面的拷貝工 
作就是白費力氣了，這種情況下，聰明的人就想出了vfork，它產生的子程序剛開始暫時與 
父程序共享地址空間（其實就是執行緒的概念了），因為這時候子程序在父程序的地址空間中 
執行，所以子程序不能進行寫操作，並且在兒子 霸佔”著老子的房子時候，要委屈老子一 
下了，讓他在外面歇著（阻塞），一旦兒子執行了exec 或者exit 後，相 於兒子買了自己的 
房子了，這時候就相 於分家了。

下面給出一個封裝好的my_system

int my_system(const char *cmdstring)
{
pid_t pid;
int status;
int i;
int ret = 0;


if(cmdstring==NULL)
{
return(1);
}


if((pid=vfork())<0)
{
nvr_printf(RED"fork error\n"RESET);
        perror("vfork()");
status=-1;
}
else
{
if(pid == 0)
{
for(i = 0; i < sysconf(_SC_OPEN_MAX); i++)
      {
close(i);
}


ret = execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
perror("execl()");
nvr_printf(GREEN"ret %d error %d\n"RESET, ret, errno);
 _exit(127); //不使用exit是為了保證程序的標準I/O流不被清掉
}
else
{
printf("pid %d\n",pid);
while((ret = waitpid(pid, &status, 0)) < 0)
     if(errno != EINTR)
{
perror("waitpid()");
nvr_printf(RED"ret%d error %d status %d\n"RESET, ret, errno, status);
status=-1; break;
}
}


}


return(status);
}