探索进程控制第一弹（进程终止、进程等待）

🕗 发布于 2024-04-15 18:06 linux 运维 服务器

文章目录

进程创建
写时拷贝
进程终止
进程等待

进程创建

初识fork函数

在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include <unistd.h>
pid_t fork(void);

返回值：自进程中返回0，父进程返回子进程id，出错返回-1。

进程=内核相关管理数据结构（task_struct、mm_struct、页表）+代码和数据

对于每一个进程都需要：

分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程
添加子进程到系统进程列表当中
fork返回，开始调度器调度

在这里插入图片描述

如何理解进程具有独立性？？子进程中也有相关管理数据结构也有自己的代码和数据，代码和数据虽然和父进程共享，但是和父进程相互不影响，数据的部分是以写时拷贝时私有，不写时拷贝相当于共享。

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程。

fork函数返回值

子进程返回0
父进程返回的是子进程的pid

如何做到有两个返回值？
探索父进程和子进程文章中有详细解释。

为什么给父进程返回的是子进程的pid，给子进程返回0？
父进程必须知道子进程的pid，方便后续对子进程进行标识，进而进行管理；子进程需要通过返回0，来看是否创建成功。

fork常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数

fork调用失败的原因

系统中有太多的进程
实际用户的进程数超过了限制

写时拷贝

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。

在这里插入图片描述

进程终止

进程终止是在做什么？

在进程创建的时候，是先有内核数据结构，再有的代码和数据。
终止一个进程的本质是在释放曾经的代码和数据所占据的空间，释放内核数据结构。
在释放内核数据结构时，PCB会延迟释放。

进程终止的情况

代码跑完，结果正确/不正确

在这里插入图片描述

main函数的返回值是100，通过echo $?查询。在系统中有一个变量叫做?，查看这个变量使用$?，访问变量内容都可以使用echo。echo是内建命令，打印的都是bash内部的变量数据。
$?表示父进程bash获取到的最近一个子进程退出的退出码。退出码为0表示成功，非0表示失败，不同的非0值一方面表示失败，另一方面表示失败原因，每个数字的错误描述都是由操作系统规定，对应的错误描述都是一个字符串。因此平时在写代码时，main函数内部都是return 0，我们在编写C/C++代码都是默认成功的。

#include<stdio.h>    
#include<unistd.h>    
#include<string.h>    
    
int main()    
{    
  for(int errcode=0;errcode<=255;errcode++)    
  {    
    printf("%d:%s\n",errcode,strerror(errcode));                                                                                         
  }    
  printf("I am process,pid:%d,ppid:%d\n",getpid(),getppid());    
  sleep(2);    
  return 100;    
}

运行结果：

[gwj@iZf8zhv7mi2thjdxsptkb8Z lesson16]$ make
gcc -o myprocess myprocess.c -std=c99
[gwj@iZf8zhv7mi2thjdxsptkb8Z lesson16]$ ./myprocess 
0:Success
1:Operation not permitted
2:No such file or directory
3:No such process
4:Interrupted system call
5:Input/output error
6:No such device or address
7:Argument list too long
8:Exec format error
9:Bad file descriptor
10:No child processes
11:Resource temporarily unavailable
12:Cannot allocate memory
13:Permission denied
14:Bad address
15:Block device required
16:Device or resource busy
17:File exists
18:Invalid cross-device link
19:No such device
20:Not a directory
21:Is a directory
22:Invalid argument
23:Too many open files in system
24:Too many open files
25:Inappropriate ioctl for device
26:Text file busy
27:File too large
28:No space left on device
29:Illegal seek
30:Read-only file system
31:Too many links
32:Broken pipe
33:Numerical argument out of domain
34:Numerical result out of range
35:Resource deadlock avoided
36:File name too long
37:No locks available
38:Function not implemented
39:Directory not empty
40:Too many levels of symbolic links
41:Unknown error 41
42:No message of desired type
43:Identifier removed
44:Channel number out of range
45:Level 2 not synchronized
46:Level 3 halted
47:Level 3 reset
48:Link number out of range
49:Protocol driver not attached
50:No CSI structure available
51:Level 2 halted
52:Invalid exchange
53:Invalid request descriptor
54:Exchange full
55:No anode
56:Invalid request code
57:Invalid slot
58:Unknown error 58
59:Bad font file format
60:Device not a stream
61:No data available
62:Timer expired
63:Out of streams resources
64:Machine is not on the network
65:Package not installed
66:Object is remote
67:Link has been severed
68:Advertise error
69:Srmount error
70:Communication error on send
71:Protocol error
72:Multihop attempted
73:RFS specific error
74:Bad message
75:Value too large for defined data type
76:Name not unique on network
77:File descriptor in bad state
78:Remote address changed
79:Can not access a needed shared library
80:Accessing a corrupted shared library
81:.lib section in a.out corrupted
82:Attempting to link in too many shared libraries
83:Cannot exec a shared library directly
84:Invalid or incomplete multibyte or wide character
85:Interrupted system call should be restarted
86:Streams pipe error
87:Too many users
88:Socket operation on non-socket
89:Destination address required
90:Message too long
91:Protocol wrong type for socket
92:Protocol not available
93:Protocol not supported
94:Socket type not supported
95:Operation not supported
96:Protocol family not supported
97:Address family not supported by protocol
98:Address already in use
99:Cannot assign requested address
100:Network is down
101:Network is unreachable
102:Network dropped connection on reset
103:Software caused connection abort
104:Connection reset by peer
105:No buffer space available
106:Transport endpoint is already connected
107:Transport endpoint is not connected
108:Cannot send after transport endpoint shutdown
109:Too many references: cannot splice
110:Connection timed out
111:Connection refused
112:Host is down
113:No route to host
114:Operation already in progress
115:Operation now in progress
116:Stale file handle
117:Structure needs cleaning
118:Not a XENIX named type file
119:No XENIX semaphores available
120:Is a named type file
121:Remote I/O error
122:Disk quota exceeded
123:No medium found
124:Wrong medium type
125:Operation canceled
126:Required key not available
127:Key has expired
128:Key has been revoked
129:Key was rejected by service
130:Owner died
131:State not recoverable
132:Operation not possible due to RF-kill
133:Memory page has hardware error
134:Unknown error 134
135:Unknown error 135
136:Unknown error 136
137:Unknown error 137
138:Unknown error 138
139:Unknown error 139
140:Unknown error 140
141:Unknown error 141
142:Unknown error 142
143:Unknown error 143
144:Unknown error 144
145:Unknown error 145
146:Unknown error 146
147:Unknown error 147
148:Unknown error 148
149:Unknown error 149
150:Unknown error 150
151:Unknown error 151
152:Unknown error 152
153:Unknown error 153
154:Unknown error 154
155:Unknown error 155
156:Unknown error 156
157:Unknown error 157
158:Unknown error 158
159:Unknown error 159
160:Unknown error 160
161:Unknown error 161
162:Unknown error 162
163:Unknown error 163
164:Unknown error 164
165:Unknown error 165
166:Unknown error 166
167:Unknown error 167
168:Unknown error 168
169:Unknown error 169
170:Unknown error 170
171:Unknown error 171
172:Unknown error 172
173:Unknown error 173
174:Unknown error 174
175:Unknown error 175
176:Unknown error 176
177:Unknown error 177
178:Unknown error 178
179:Unknown error 179
180:Unknown error 180
181:Unknown error 181
182:Unknown error 182
183:Unknown error 183
184:Unknown error 184
185:Unknown error 185
186:Unknown error 186
187:Unknown error 187
188:Unknown error 188
189:Unknown error 189
190:Unknown error 190
191:Unknown error 191
192:Unknown error 192
193:Unknown error 193
194:Unknown error 194
195:Unknown error 195
196:Unknown error 196
197:Unknown error 197
198:Unknown error 198
199:Unknown error 199
200:Unknown error 200
201:Unknown error 201
202:Unknown error 202
203:Unknown error 203
204:Unknown error 204
205:Unknown error 205
206:Unknown error 206
207:Unknown error 207
208:Unknown error 208
209:Unknown error 209
210:Unknown error 210
211:Unknown error 211
212:Unknown error 212
213:Unknown error 213
214:Unknown error 214
215:Unknown error 215
216:Unknown error 216
217:Unknown error 217
218:Unknown error 218
219:Unknown error 219
220:Unknown error 220
221:Unknown error 221
222:Unknown error 222
223:Unknown error 223
224:Unknown error 224
225:Unknown error 225
226:Unknown error 226
227:Unknown error 227
228:Unknown error 228
229:Unknown error 229
230:Unknown error 230
231:Unknown error 231
232:Unknown error 232
233:Unknown error 233
234:Unknown error 234
235:Unknown error 235
236:Unknown error 236
237:Unknown error 237
238:Unknown error 238
239:Unknown error 239
240:Unknown error 240
241:Unknown error 241
242:Unknown error 242
243:Unknown error 243
244:Unknown error 244
245:Unknown error 245
246:Unknown error 246
247:Unknown error 247
248:Unknown error 248
249:Unknown error 249
250:Unknown error 250
251:Unknown error 251
252:Unknown error 252
253:Unknown error 253
254:Unknown error 254
255:Unknown error 255
I am process,pid:32312,ppid:31371

对应的错误码都表示一种错误。

父进程为什么知道子进程退出码？父进程要知道子进程的退出情况（失败了还是成功了，失败的原因是什么），bash会反馈给用户。

举个例子：

在这里插入图片描述

进程的退出码存在的意义是告诉关心方（父进程），我把任务执行的怎么样了。既然把子进程创建出来，就要让父进程得到信息。

在这里插入图片描述

不是说echo $?保存的是最近一个子进程退出的退出码吗？那上图怎么解释？方框中第一个echo $?执行的命令是查看process的退出码，第二个echo $?查看的是第一个echo $?的退出码，虽然echo是一个内建命令，但是也是当做进程来看待。

进程的退出码可以使用系统官方的定义，你也可以自定义一个退出码。

代码异常终止

代码执行时，出现了异常，提前退出，一旦进程出现异常，退出码有没有意义了

vs编写程序运行时，程序崩溃了，本质是操作系统发现你的程序做了不该做的事情，操作系统杀掉了你的进程。

为什么进程会出现异常？
本质上是因为进程收到了操作系统发出的信号。

段错误，操作系统提前终止进程。

在这里插入图片描述
尽管书写的代码进程没有错误，但是接收到了信号，就会有段错误。

进程退出时，我们可以看进程退出信号是多少来判断进程为什么异常。

进程退出的三种情况：
代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

因此，衡量一个进程退出，我们只需要看两个数字：退出码、退出信号

如何终止

main函数中直接return，表示进程终止（非main函数，return函数结束）
代码调用exit()，注意：在代码任意位置调用都表示进程终止。

#include<stdio.h>    
#include<unistd.h>    
#include<string.h>    
#include<stdlib.h>                                                 
int main()    
{    
  while(1)    
  {    
    printf("I am process,pid:%d,ppid:%d\n",getpid(),getppid());
    sleep(2);    
    exit(123);    
  }    
  return 100;    
}

在这里插入图片描述

#include <unistd.h>
void exit(int status);

exit最后也会调用exit, 但在调用exit之前，还做了其他工作：

执行用户通过 atexit或on_exit定义的清理函数。
关闭所有打开的流，所有的缓存数据均被写入
调用_exit

调用_exit()函数

#include <unistd.h>
void _exit(int status);

参数：status 定义了进程的终止状态，父进程通过wait来获取该值
说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

#include<stdio.h>    
#include<unistd.h>    
#include<string.h>    
#include<stdlib.h>                                                 
int main()    
{    
  while(1)    
  {    
    printf("I am process,pid:%d,ppid:%d\n",getpid(),getppid());
    sleep(2);    
    _exit(-1);    
  }    
  return 100;    
}

在这里插入图片描述

exit和_exit区别：
exit会在程序退出时，冲刷缓冲区，_exit不会。

在这里插入图片描述

进程等待

概述

什么是进程等待？
任何子进程，在退出的情况下，一般必须要被父进程等待。 进程在退出的时候，如果父进程不管不顾，退出进程，处于僵尸状态（Z），存在内存泄漏。

为什么？

父进程通过等待，解决子进程退出的僵尸问题，回收系统资源（一定要考虑的）
父进程获取子进程的退出信息，知道子进程退出原因（可选的功能）

进程等待方法

wait方法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);

返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL。

代码势力：

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>

void ChildRun()
{
  int cnt=5;
  while(cnt)
  {
    printf("I am child process,pid:%d,ppid:%d,cnt=%d\n",getpid(),getppid(),cnt);
    sleep(1);
    cnt--;
  }
}

int main()
{
  printf("I am father,pid:%d,ppid:%d\n",getpid(),getppid());
  pid_t id=fork();

  if(id==0)                                                                        
  {
    //child
    ChildRun();
    printf("child process quit...\n");
    exit(0);
  }

  sleep(10);
  //father
  pid_t rid=wait(NULL);
  if(rid>0)
  {
    printf("wait process,rid:%d\n",rid);
  }

  sleep(3);
  printf("father process quit...\n");
  return 0;
}

运行结果：

在这里插入图片描述

在上述代码中，先进入父进程，然后子进程运行五次后子进程退出，然后休眠10秒，处于僵尸状态，紧接着进程等待，然后父进程退出，程序运行结束。由此可以看出，等待会解决进程的僵尸问题。

将上述代码sleep(10)代码注释掉，子进程运行5秒后直接退出，立马执行父进程等待。如果子进程没有退，其实父进程一直在阻塞等待。子进程本身是软件，父进程本质是在等待某种软件就绪。
进程的等待本质是将进程的PCB列入等待队列。那么如何理解父进程阻塞等待子进程？父进程不被调度，在执行wait发现子进程还没有退出，父进程就不要调度，实际上就是将父进程PCB列入等待队列，处于S状态（非运行状态），等到子进程退出，唤醒父进程。

waitpid

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);

pid_t waitpid(pid_t pid, int *status, int options);

int  waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

返回值：

当正常返回的时候waitpid返回收集到的子进程的进程ID；
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；

参数：
[ ]
pid：

Pid=-1,等待任一个子进程。与wait等效。
pid_t rid=waitpid(-1,NULL,0);等待任何一个子进程退出，哪一个进程退了，就对应返回哪一个进程的pid。等同于 pid_t rid=wait(NULL);
Pid>0.等待其进程ID与pid相等的子进程。
pid_t rid=waitpid(id,NULL,0);

status:典型输出型参数

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

以位图的形式返回
在这里插入图片描述
退出码范围：0~255
信号终止：128个

代码：

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>

void ChildRun()
{
  int cnt=5;
  while(cnt)
  {
    printf("I am child process,pid:%d,ppid:%d,cnt=%d\n",getpid(),getppid(),cnt);
    sleep(1);
    cnt--;
  }
}

int main()
{
  printf("I am father,pid:%d,ppid:%d\n",getpid(),getppid());
  pid_t id=fork();

  if(id==0)                                                                                                                        
  {
    //child
    ChildRun();
    printf("child process quit...\n");
    exit(1);
  }

  sleep(7);
  //father
  //pid_t rid=wait(NULL);
  int status=0;
  pid_t rid=waitpid(id,&status,0);
  if(rid>0)
  {
    printf("wait process,rid:%d\n",rid);
  }

  sleep(3);
  printf("father process quit,status:%d,child quit code:%d,child quit signal:%d\n",status,(status>>8)&0xFF,status & 0x7F);

  return 0;
}

运行结果：

在这里插入图片描述

宏定义方式等待：

在这里插入图片描述

等待是必须的，但获取子进程的退出信息不是必须的。

如果子进程没有退出，而父进程在执行waitpid进行等待，阻塞等待，这本质上是进程阻塞，waitpid在等待某种条件发生（子进程退出），在等待期间，父进程什么也没干。

接下来就介绍非阻塞等待！！！

options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。
pid_t>0：等待成功，子进程退出，并且父进程回收成功
pid_t<0：等待失败
pid_t==0：检测成功，但是子进程还没有退出，需要进行下一次重复等待。
非阻塞等待的时候+循环=非阻塞轮询
好处：允许父进程做一些其他的事情

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>

void ChildRun()
{
  int cnt=5;
  while(cnt)
  {
    printf("I am child process,pid:%d,ppid:%d,cnt=%d\n",getpid(),getppid(),cnt);
    sleep(1);
    cnt--;
  }
}

int main()
{
  printf("I am father,pid:%d,ppid:%d\n",getpid(),getppid());
  pid_t id=fork();
if(id==0)
  {
    //child
    ChildRun();
    printf("child process quit...\n");
    exit(1);
  }
  
  //father
  while(1)                                                                                                                               
  {
      int status=0;
      pid_t rid=waitpid(id,&status,WNOHANG);
      if(rid==0)
      {
        sleep(1);
        printf("child is running,father check next time!\n");
      }
      else if(id>0)
      {
        if(WIFEXITED(status))
        {
          printf("child quit success,child exit code:%d\n",WEXITSTATUS(status));
        }
        else 
        {
          printf("child quit unnormal!\n");
        }
        break;
      }
      else 
      {
        printf("waitpid failed!\n");
        break;
      }
  }
}

在这里插入图片描述

原文地址：https://blog.csdn.net/weixin_73397765/article/details/137391843

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：基于FPGA轻松玩转AI
下一篇：探索314协议代币合约开发：解析AVE热搜上币与项目推广

Dubbo 使用轻量的 Java SDK 开发 RPC Server 和 Client
Dubbo 使用轻量的 Java SDK 开发 RPC Server 和 Client
阅读更多2024-11-17
Linux TCP服务器客户端
【代码】Linux TCP服务器客户端。
阅读更多2024-11-17
spark性能优化调优指导性文件
没有任务的并行性，整个队列资源将被独占消耗，其他同学的任务无法执行。由于集群的 Spark History Server 还没安装调试好，没法通过 spark web UI 查看历史任务的可视化执行细
阅读更多2024-11-17
Docker 安装全平台详细教程
1. **Docker 基本命令**：如 `docker build`, `docker run`, `docker ps`, `docker stop` 等。- **解决办法**：进入 BIOS，启
阅读更多2024-11-17
爬虫——数据解析与提取
在网络爬虫开发中，获取网页内容（HTML）是第一步，但从这些内容中提取有用的数据，才是爬虫的核心部分。虽然它不是专门为HTML解析设计的，但在一些简单的抓取任务中，正则表达式仍然是不可或缺的。因此，开
阅读更多2024-11-17
爬虫基础总结 —— 附带爬取案例
正则表达式（Regular Expression，简称regex或regexp）是一种文本模式描述的方法，它可以用来检索、替换符合某个模式（规则）的文本。正则表达式由一系列字符组成，这些字符可以是普通
阅读更多2024-11-17
WebSocket Endpoint端点
WebSocket端点（WebSocket Endpoint）是指在WebSocket协议中，服务器和客户端之间的通信通道的终端。在Java中，通常使用 @ServerEndpoint 注解来标识一个
阅读更多2024-11-17
简单淘宝网页api怎么写
以下是一个简单示例，展示如何使用 Python 的requests。
阅读更多2024-11-17
Python issubclass和isinstance函数：检查类型
isinstance 可以用于实例对象和类对象（在用于类对象时，相当于检查该类是否是给定类的子类）。返回值：如果class是classinfo的子类（或相同类），则返回True；classinfo：可
阅读更多2024-11-17
51c大模型~合集49
我自己的原文哦~ https://blog.51cto.com/whaosoft/11960038任意论文一键变播客，谷歌正式发布Illuminate，它能重构研究者的学习方式吗？先来听一段英文播客，
阅读更多2024-11-17

探索进程控制第一弹（进程终止、进程等待）

文章目录

进程创建

初识fork函数

fork函数返回值

fork常规用法

fork调用失败的原因

写时拷贝

进程终止

进程终止是在做什么？

进程终止的情况

代码跑完，结果正确/不正确

代码异常终止

如何终止

进程等待

概述

进程等待方法

wait方法

waitpid

相关文章