Linux系统应用编程---进程原语（fork、exec、wait&waitpid）-阿里云开发者社区

fork

子进程复制父进程的0到3g空间和父进程内核中的PCB，但id号不同。

程序一讲解：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
4. 
5. int main(void)
6. {     
7. //fork创建一个新进程
8.        pid_t p1 = -1;
9. 
10. //fork之前的操作只有父父进程才有
11.        p1 = fork();    //调用一次fork函数会返回两次
12. 
13. if(p1 == 0)
14.        {
15. //这里一定是子进程
16. //先sleep一下，让父进程先死
17.               sleep(1);
18. 
19.               printf("子进程, pid = %d.\n", getpid());
20.               printf("子进程, p1 = %d.\n", p1);
21.               printf("子进程中父进程的ID = %d.\n", getppid());
22.        }
23. if(p1 > 0)
24.        {
25. //这里一定是父进程
26.               printf("父进程, pid = %d.\n", getpid());
27.               printf("父进程, p1 = %d.\n", p1);
28.        }
29. 
30. if(p1 < 0)
31.        {
32. 
33. //这里一定是出错了
34.        }
35. 
36. //在这里的操作，父子进程都有
37. //printf("hello world, pid = %d.\n", getpid());
38. 
39. return 0;
40. }

输出结果如下

结论：

（1）fork函数调用一次会返回两次，返回值等于0的就是子进程，返回值大于0的就是父进程

（2）fork的返回值在子进程中等于0，在父进程中返回值等于本次fork创建的子进程的PID

（3）这里在子进程中打印父进程PID，为什么跟在父进程中打印父进程的PID结果不一样？

是因为在执行的时候，父进程先执行完，然后子进程就没有父进程了；这是在子进程中打印的父进程PID就是init进程

程序二讲解：

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
4. #include <sys/types.h>
5. 
6. int main(void)
7. {
8.        pid_t pid ;
9. //调用一次返回2次，在父进程返回子进程的PID，在子进程中返回0
10. 
11.        int n = 10;
12.        pid = fork();
13. 
14. if(pid > 0)
15.        {/*in parent*/
16.               while(1)
17.               {
18.                      printf("I am parent %d\n", n++);
19.                      printf("my pid = %d.\n", getpid());
20.                      printf("my parent pid = %d.\n", getppid());
21.                      sleep(1);
22.               }
23.        }
24. 
25. else if(pid == 0)
26.        {/*in child*/
27.               while(1)
28.               {
29.                      printf("I am child %d\n", n++);
30.                      printf("my pid = %d.\n", getpid());
31.                      printf("my parent pid = %d.\n", getppid());
32.                      sleep(3);
33. 
34.               }
35.        }
36. 
37. else
38.        {
39.               perror("fork");
40. exit(0);
41.        }
42. 
43. return 0;
44. }

（1）父子进程中n值分别独立加，说明子进程从父进程中克隆过来的数据，已经不是共享的了。两者有自己独立的空间。

（2）0-3G放应用层代码，子进程直接从父进程中拷贝，3-4G是内核空间

（3）读时共享，写时复制（copy on write）（好处：节省物理内存开销，省去直接复制的时间）

fork创建了子进程之后，调用exec函数执行子进程

exec函数

用fork创建子进程后执行的是和父进程相同的程序，可以通过if判断pid的返回值让子进程执行不同的代码分支，这样设计程序不灵活。通过调用exec函数，用新程序将子进程的用户空间代码和数据替换，直接去执行新程序。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。

其实有六种以exec开头的函数，统称exec函数：

1. #include <unistd.h>
2. 
3. int execl(const char *path, const char *arg, ...);
4. 
5. int execlp(const char *file, const char *arg, ...);
6. 
7. int execle(const char *path, const char *arg, ..., char *const envp[]);
8. 
9. int execv(const char *path, char *const argv[]);
10. 
11. int execvp(const char *file, char *const argv[]);
12. 
13. int execve(const char *path, char *const argv[], char *const envp[]);

这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回，如果调用出错

则返回-1，所以exec函数只有出错的返回值而没有成功的返回值。

程序1：

1. #include <stdio.h>
2. #include <unistd.h>
3. 
4. 
5. int main(void)
6. {
7. printf("hello.\n");
8. execl("/bin/ls", "ls", "-l", NULL);
9. printf("world.\n");
10. return 0;
11. }

执行结果：

分析：

可以看到没有执行 printf(“world.\n”);

这是因为/bin/ls加载到用户用户空间替换了原来代码段，所以execl下面的代码就不会执行了。所以程序是从ls的return 0退出程序的。

函数辨析

execl与execlp

execl("/bin/ls", "ls", "-l", NULL);

execlp("ls", "ls", "-l", NULL);

execl要给全执行进程的路径，而execlp除了在当前路径下找，还可以去PATH环境变量底下找。p就是去环境变量底下找，不加p就是在当前路径下找，所以要给全路径

execv与execvp

这两个函数的功能跟excel与execlp的功能一样，只是将参数列表以数组指针的方式给出。

还是用上面执行ls举例

char *argvv[] = {“ls”, “-l”, NULL};

execv(“/bin/ls”, argvv); execvp(“ls”, argvv);

execle execve中添加了一个替换环境变量的参数，在加载新的程序的时候，我们可以不用原来的环境变量。（这两个函数实际用的很少）

wait & waitpid

僵尸进程

(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被称为僵尸进程。

(2)子进程除 task_struct 和栈外其余内存空间皆已清理

(3)父进程可以使用 wait 或 waitpid 以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。【父进程帮子进程收尸是要调用函数的】

(4)父进程也可以不使用 wait 或者 waitpid 回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用 wait/waitpid 来回收子进程从而造成内存泄漏）

孤儿进程

(1)父进程先于子进程结束，子进程成为一个孤儿进程。

(2)linux 系统规定：所有的孤儿进程都自动成为一个特殊进程（进程 1，也就是 init 进程）的子进程。

1. #include <sys/types.h>
2. 
3. #include <sys/wait.h>
4. 
5. pid_t wait(int *status);
6. 
7. pid_t waitpid(pid_t pid, int *status, int options);

wait返回值：成功回收子进程，返回终止的子进程的pid，错误返回-1

（1）waitpid参数含义：

参数值	含义
pid<-1	等待进程组号为pid绝对值的任何子进程。
pid=-1	等待任何子进程，此时的waitpid()函数就退化成了普通的wait()函数。
pid=0	等待进程组号与目前进程相同的任何子进程，也就是说任何和调用waitpid()函数的进程在同一个进程组的进程。
pid>0	等待进程号为pid的子进程。

（2）int *status

这个参数将保存子进程的状态信息，有了这个信息父进程就可以了解子进程为什么会退出，是正常退出还是出了什么错误。如果status不是空指针，则状态信息将被写入寄存器指向的位置。当然，如果不关心子进程为什么推出的话，也可以传入空指针。

Linux提供了一些非常有用的宏来帮助解析这个状态信息，这些宏都定义在sys/wait.h头文件中。主要有以下几个：

宏	说明
WIFEXITED(status)	如果子进程正常结束，它就返回真；否则返回假。
WEXITSTATUS(status)	如果WIFEXITED(status)为真，则可以用该宏取得子进程exit()返回的结束代码。
WIFSIGNALED(status)	如果子进程因为一个未捕获的信号而终止，它就返回真；否则返回假。
WTERMSIG(status)	如果WIFSIGNALED(status)为真，则可以用该宏获得导致子进程终止的信号代码。
WSTOPSIG(status)	如果当前子进程被暂停了，则返回真；否则返回假。
WIFSTOPPED(status)	如果WIFSTOPPED(status)为真，则可以使用该宏获得导致子进程暂停的信号代码。

（3）int options

参数options提供了一些另外的选项来控制waitpid()函数的行为。如果不想使用这些选项，则可以把这个参数设为0。主要使用的有以下两个选项：

参数	说明
WNOHANG	如果pid指定的子进程没有结束，则waitpid()函数立即返回0，而不是阻塞在这个函数上等待；如果结束了，则返回该子进程的进程号。
WUNTRACED	如果子进程进入暂停状态，则马上返回。

这些参数可以用“|”运算符连接起来使用。

如果waitpid()函数执行成功，则返回子进程的进程号；如果有错误发生，则返回-1，并且将失败的原因存放在errno变量中。

失败的原因主要有：没有子进程（errno设置为ECHILD），调用被某个信号中断（errno设置为EINTR）或选项参数无效（errno设置为EINVAL）

如果像这样调用waitpid函数：waitpid(-1, status, 0)，这此时waitpid()函数就完全退化成了wait()函数。

程序1

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
4. #include <sys/types.h>
5. #include <wait.h>
6. 
7. int main(void)
8. {
9.        pid_t pid, pid_c;
10. //调用一次返回2次，在父进程返回子进程的PID，在子进程中返回0
11. 
12.        int n = 10;
13.        pid = fork();
14. 
15. if(pid > 0)
16.        {/*in parent*/
17.               while(1)
18.               {
19.                      printf("I am parent pid = %d\n", getpid());
20.                      pid_c = wait(NULL);            //wait是一个阻塞函数，等待回收子进程资源
21. 
22. //如果没有子进程，wait返回-1
23.                      printf("wait for child %d.\n", pid_c);
24.                      sleep(1);
25.               }
26.        }
27. 
28. else if(pid == 0)
29.        {/*in child*/
30. //printf("I am child %d\n", n++);
31.               printf("I am child pid = %d.\n", getpid());
32. //printf("my parent pid = %d.\n", getppid());
33.               sleep(10);
34.        }
35. 
36. else
37.        {
38.               perror("fork");
39. exit(0);
40.        }
41. 
42. return 0;
43. }

编译之后，程序执行结果如下：

刚进来的时候打印一次父子进程的ID号，然后子进程slepp 10s，父进程执行wait等待回收子进程，阻塞在这里，直到子进程结束。子进程结束之后，wait的返回值就是-1.

僵尸进程对内存的影响：子进程如果没有回收，子进程占了一个PCB，浪费内存，造成内存泄露。

程序2：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
4. #include <wait.h>
5. 
6. 
7. int main(void)
8. {
9. 
10.        pid_t pid;
11. 
12.        int n = 3;
13. 
14.        while(n--)
15.        {
16.               pid = fork();
17. if(pid == 0) break;
18.        }
19. 
20. if(pid == 0)
21.        {
22. //while(1)
23.               {
24.                      printf("I am child %d.\n", getpid());
25.                      sleep(3);
26.               }
27.        }
28. 
29. else if(pid > 0)
30.        {
31. 
32.               pid_t pid_c;
33.               while(1){
34. 
35. //pid_c = wait(NULL);
36.                      printf("I am parent.\n");
37.                      pid_c = waitpid(0, NULL, WNOHANG);
38. 
39. if(pid_c == -1)     
40. continue;
41. else
42.                             printf("wait for child %d.\n", pid_c);
43. if(pid_c > 0){
44.                             n++;     
45.                      }
46. if(n == 2)
47.                             break;                  
48.                      sleep(1);
49.               }
50.        }
51. 
52. return 0;
53. }