Linux系统应用编程---进程原语(fork、exec、wait&waitpid)

简介: 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值分别独立加,说明子进程从父进程中克隆过来的数据,已经不是共享的了。两者有自己独立的空间。

(20-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. }

一个父进程fork了三个子进程,通过ps – ajx查看

 

可以看到三个子进程的pid号依次递增,,父进程与三个子进程同属于一个进程组。(父进程创建子进程之后,子进程跟父进程默认是一个组)

如何kill掉一个进程组,命令【kill -9 -14943】

注释掉while(1),执行之后可以看到,通过WNOHANG确实将waitpid设置成了非阻塞的。

目录
相关文章
|
3天前
|
存储 JSON Linux
|
1天前
|
JavaScript 前端开发 Linux
【好玩的开源项目】Linux系统之部署捕鱼达人经典小游戏
【7月更文挑战第20天】Linux系统之部署捕鱼达人经典小游戏
11 6
|
3天前
|
Linux 测试技术 网络安全
【好玩的开源项目】Linux系统之部署吃豆人经典小游戏
【7月更文挑战第18天】Linux系统之部署吃豆人经典小游戏
20 1
|
3天前
|
JavaScript Linux 测试技术
【好玩的开源项目】Linux系统之部署proxx扫清黑洞小游戏
【7月更文挑战第17天】Linux系统之部署proxx扫清黑洞小游戏
13 1
|
25天前
|
监控 Linux 应用服务中间件
探索Linux中的`ps`命令:进程监控与分析的利器
探索Linux中的`ps`命令:进程监控与分析的利器
|
12天前
|
存储 缓存 安全
【Linux】冯诺依曼体系结构与操作系统及其进程
【Linux】冯诺依曼体系结构与操作系统及其进程
120 1
|
19天前
|
小程序 Linux
【编程小实验】利用Linux fork()与文件I/O:父进程与子进程协同实现高效cp命令(前半文件与后半文件并行复制)
这个小程序是在文件IO的基础上去结合父子进程的一个使用,利用父子进程相互独立的特点实现对数据不同的操作
|
19天前
|
SQL 自然语言处理 网络协议
【Linux开发实战指南】基于TCP、进程数据结构与SQL数据库:构建在线云词典系统(含注册、登录、查询、历史记录管理功能及源码分享)
TCP(Transmission Control Protocol)连接是互联网上最常用的一种面向连接、可靠的、基于字节流的传输层通信协议。建立TCP连接需要经过著名的“三次握手”过程: 1. SYN(同步序列编号):客户端发送一个SYN包给服务器,并进入SYN_SEND状态,等待服务器确认。 2. SYN-ACK:服务器收到SYN包后,回应一个SYN-ACK(SYN+ACKnowledgment)包,告诉客户端其接收到了请求,并同意建立连接,此时服务器进入SYN_RECV状态。 3. ACK(确认字符):客户端收到服务器的SYN-ACK包后,发送一个ACK包给服务器,确认收到了服务器的确
142 1
|
25天前
|
Web App开发 运维 监控
深入探索Linux命令pwdx:揭秘进程工作目录的秘密
`pwdx`命令在Linux中用于显示指定进程的工作目录,基于`/proc`文件系统获取实时信息。简单易用,如`pwdx 1234`显示PID为1234的进程目录。结合`ps`和`pgrep`等命令可扩展使用,如查看所有进程或特定进程(如Firefox)的目录。使用时注意权限、进程ID的有效性和与其他命令的配合。查阅`man pwdx`获取更多帮助。
|
27天前
|
存储 Shell Linux
Linux进程概念(下)
本文详细的介绍了环境变量和进程空间的概念及其相关的知识。
24 0
Linux进程概念(下)