Linux系统编程——vfork() 函数详解

所需头文件：

#include <sys/types.h>

#include <unistd.h>

pid_t vfork(void);

功能：

vfork() 函数和 fork() 函数（fork()如何使用，请点此链接）一样都是在已有的进程中创建一个新的进程，但它们创建的子进程是有区别的。

参数：

无

返回值：

成功：子进程中返回 0，父进程中返回子进程 ID。pid_t，为无符号整型。

失败：返回 -1。

fork() 与 vfock() 都是创建一个进程，那它们有什么区别呢？

1）fork()： 父子进程的执行次序不确定。

   vfork()：保证子进程先运行,在它调用 exec（进程替换） 或 exit（退出进程）之后父进程才可能被调度运行。

2）fork()： 子进程拷贝父进程的地址空间，子进程是父进程的一个复制品。

   vfork()：子进程共享父进程的地址空间（准确来说，在调用 exec（进程替换） 或 exit（退出进程） 之前与父进程数据是共享的）

下面我们写一个例子来测试，通过 vfork() 创建的子进程会执行完后，才到父进程执行：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4.   
5. int main(int argc, char *argv[])  
6. {  
7.     pid_t pid;  
8.       
9.     pid = vfork();  // 创建进程  
10.     if(pid < 0){ // 出错  
11.         perror("vfork");  
12.     }  
13.       
14.     if(0 == pid){ // 子进程  
15.       
16.         sleep(3); // 延时 3 秒  
17.         printf("i am son\n");  
18.           
19.         _exit(0); // 退出子进程，必须  
20.     }else if(pid > 0){ // 父进程  
21.           
22.         printf("i am father\n");  
23.           
24.     }  
25.       
26.     return 0;  
27. }  

上面的代码，已经让子进程延时 3 s，结果还是子进程运行结束后，父进程才执行，运行结果如下：

接下来，我们一起验证，子进程共享父进程的地址空间：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4.   
5. int a = 10;  
6.   
7. int main(int argc, char *argv[])  
8. {  
9.     pid_t pid;  
10.       
11.     int b = 20;  
12.       
13.     pid = vfork();  // 创建进程  
14.     if(pid < 0){ // 出错  
15.         perror("vfork");  
16.     }  
17.       
18.     if(0 == pid){ // 子进程  
19.       
20.         a = 100, b = 200;  
21.         printf("son: a = %d, b = %d\n", a, b);  
22.           
23.         _exit(0); // 退出子进程，必须  
24.     }else if(pid > 0){ // 父进程  
25.           
26.         printf("father: a = %d, b = %d\n", a, b);  
27.           
28.     }  
29.       
30.     return 0;  
31. }  

通常运行结果得知，子进程修改 a, b 的值，会影响到父进程的 a, b, 效果图如下：

vfork() 保证子进程先运行，在它调用 exec（进程替换） 或 exit（退出进程）之后父进程才可能被调度运行。如果子进程没有调用 exec, exit, 程序则会导致死锁，程序是有问题的程序，没有意义，测试代码如下：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4.   
5. int main(int argc, char *argv[])  
6. {  
7.     pid_t pid;  
8.       
9.     pid = vfork();  // 创建进程  
10.     if(pid < 0){ // 出错  
11.         perror("vfork");  
12.     }  
13.       
14.     if(0 == pid){ // 子进程  
15.       
16.         printf("i am son\n");  
17.         sleep(1);  
18.           
19.         // 子进程没有调用 exec 或 exit  
20.     }else if(pid > 0){ // 父进程  
21.           
22.         printf("i am father\n");  
23.         sleep(1);  
24.     }  
25.       
26.     return 0;  
27. }  

运行结果如下：

所以，用 vfork() 创建进程，子进程里一定要调用 exec（进程替换） 或 exit（退出进程），否则，程序会出问题，没有意义。

转载自http://blog.csdn.net/tennysonsky