【Linux系统编程】—— 深度解析进程等待与终止：系统高效运行的关键

文章目录

进程创建
- 再次认识fork()函数
- fork()函数返回值
写时拷贝
- fork常规⽤法以及调用失败的原因
进程终⽌
- 进程终止对应的三种情况
- 进程常⻅退出⽅法
- _exit函数
- exit函数
- return退出
进程等待
- 进程等待的必要性
- 进程等待的⽅法

进程创建

再次认识fork()函数

fork函数初识：在linux中fork函数是⾮常重要的函数，它从已存在进程中创建⼀个新进程。新进程为⼦进程，⽽原进程为⽗进程。

#include <unistd.h>
pid_t fork(void);
返回值：⾃进程中返回0，⽗进程返回⼦进程id，出错返回-1

进程调⽤fork，当控制转移到内核中的fork代码后，内核做：

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

在这里插入图片描述

可以看到，里面创建了一个进程pid3109，这其实就是子进程。

当⼀个进程调⽤fork之后，就有两个⼆进制代码相同的进程。⽽且它们都运⾏到相同的地⽅。但每个进
程都将可以开始它们⾃⼰的旅程，看如下程序。

int main( void )
{
	pid_t pid;
	printf("Before: pid is %d\n", getpid());
	if ( (pid=fork()) == -1 )perror("fork()"),exit(1);
	printf("After:pid is %d, fork return %d\n", getpid(), pid);
	sleep(1);
	return 0;
}

运⾏结果：

[root@localhost linux]# ./a.out
Before: pid is 43676
After:pid is 43676, fork return 43677
After:pid is 43677, fork return 0

这⾥看到了三⾏输出，⼀⾏before，两⾏after。进程43676先打印before消息，然后它有打印after。
另⼀个after消息有43677打印的。注意到进程43677没有打印before，为什么呢？如下图所⽰
在这里插入图片描述
所以，fork之前⽗进程独⽴执⾏，fork之后，⽗⼦两个执⾏流分别执⾏。注意，fork之后，谁先执⾏完全由调度器决定。

fork()函数返回值

⼦进程返回0，
⽗进程返回的是⼦进程的pid。

写时拷贝

写时拷贝（Copy-on-write, COW）是一种优化技术，广泛应用于计算机系统中，特别是在操作系统、虚拟化和内存管理领域。其主要目的是节省内存资源和提高效率。

工作原理：
写时拷贝的基本思想是，当多个进程共享相同的资源（例如内存或文件）时，如果一个进程对这些资源进行修改，系统并不会立即为该进程创建资源的副本，而是推迟到该进程真正进行修改时，才为它分配一个新的副本。具体步骤如下：

共享资源：多个进程最初可以共享同一块内存区域或文件（即资源是只读的）。
标记只读：系统会将这些共享的资源标记为只读。
修改时拷贝：当一个进程尝试修改共享资源时，操作系统会为该进程创建资源的副本，并将其设为可写。其他进程仍然使用原始资源，而修改的进程则使用新的副本。
继续共享：如果其他进程继续只读访问原始资源，不会进行拷贝，节省内存和计算资源。
具体的理解可以看下面这一张图片：

优点：

节省内存：由于多个进程或线程可以共享同一资源副本，减少了内存的消耗。
提高性能：避免不必要的拷贝操作，只有在修改资源时才进行拷贝，从而提高了效率。
提高数据一致性：写时拷贝确保在修改数据时不会影响其他进程或线程读取到的数据，避免了数据冲突。

缺点：

延迟开销：在第一次修改资源时，系统需要创建资源的副本，这可能带来一定的性能开销。
资源消耗：如果多个进程频繁进行写操作，系统会进行多次资源拷贝，可能增加资源消耗。

fork常规⽤法以及调用失败的原因

⼀个⽗进程希望复制⾃⼰，使⽗⼦进程同时执⾏不同的代码段。例如，⽗进程等待客⼾端请求，⽣成⼦进程来处理请求。
⼀个进程要执⾏⼀个不同的程序。例如⼦进程从fork返回后，调⽤exec函数。

原因：

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

进程终⽌

进程终⽌的本质是释放系统资源，就是释放进程申请的相关内核数据结构和对应的数据和代码。

进程终止对应的三种情况

代码运⾏完毕，结果正确
代码运⾏完毕，结果不正确
代码异常终止

进程常⻅退出⽅法

正常终⽌（可以通过 echo $? 查看进程退出码）：

从main返回
调⽤exit
_exit

异常退出：

ctrl + c，信号终⽌

退出码（退出状态）可以告诉我们最后⼀次执⾏的命令的状态。在命令结束以后，我们可以知道命令是成功完成的还是以错误结束的。其基本思想是，程序返回退出代码 0 时表⽰执⾏成功，没有问题。

代码 1 或 0 以外的任何代码都被视为不成功。

下面是Linuxshell常见的退出码
在这里插入图片描述

_exit函数

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终⽌状态，⽗进程通过wait来获取该值

说明：虽然status是int，但是仅有低8位可以被⽗进程所⽤。所以_exit(-1)时，在终端执⾏$?发现返回值是255。

exit函数

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

exit最后也会调⽤_exit, 但在调⽤_exit之前，还做了其他⼯作：

执⾏⽤⼾通过 atexit或on_exit定义的清理函数。
关闭所有打开的流，所有的缓存数据均被写⼊
调⽤_exit

示例；

int main()
{
printf("hello");
exit(0);
}

int main()
{
printf("hello");
_exit(0);
}

上面的结果分别为：

运⾏结果:
[root@localhost linux]# ./a.out
hello[root@localhost linux]#
运⾏结果:
[root@localhost linux]# ./a.out
[root@localhost linux]#

return退出

return是⼀种更常⻅的退出进程⽅法。执⾏return n等同于执⾏exit(n),因为调⽤main的运⾏时函数会将main的返回值当做 exit的参数。

进程等待

进程等待是指在操作系统中，当一个进程无法继续执行时，它进入一种阻塞状态，等待某些条件或事件的发生才能恢复执行。等待通常发生在进程需要等待资源（如CPU、内存、I/O设备等）或与其他进程之间的同步和通信。

进程等待的必要性

资源共享与避免冲突：多个进程共享资源时，等待机制确保不会发生冲突，避免竞争条件。
进程同步与通信：确保进程按照正确顺序执行，例如生产者和消费者模型。
CPU资源管理：避免无谓的CPU占用，让等待的进程释放CPU，提高系统效率。
防止死锁：通过合理设计等待策略，避免多个进程互相等待，进入死锁状态。
提升并发性：使系统能够并发执行多个进程，最大化资源利用。
提高系统稳定性：管理进程优先级，保证重要任务及时执行，确保系统稳定运行。

进程等待的⽅法

wait⽅法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取⼦进程退出状态,不关⼼则可以设置成为NULL

waitpid⽅法

pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
当正常返回的时候waitpid返回收集到的⼦进程的进程ID；
如果设置了选项WNOHANG,⽽调⽤中waitpid发现没有已退出的⼦进程可收集,则返回0；
如果调⽤中出错,则返回-1,这时errno会被设置成相应的值以指⽰错误所在；
参数：
pid：
Pid=-1,等待任⼀个⼦进程。与wait等效。
Pid>0.等待其进程ID与pid相等的⼦进程。
status: 输出型参数
WIFEXITED(status): 若为正常终⽌⼦进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED⾮零，提取⼦进程退出码。（查看进程的退出码）
options:默认为0，表⽰阻塞等待。
WNOHANG: 若pid指定的⼦进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该⼦进程的ID。

如果⼦进程已经退出，调⽤wait/waitpid时，wait/waitpid会⽴即返回，并且释放资源，获得⼦进程退出信息。
如果在任意时刻调⽤wait/waitpid，⼦进程存在且正常运⾏，则进程可能阻塞。
如果不存在该⼦进程，则⽴即出错返回。

获取⼦进程status

wait和waitpid，都有⼀个status参数，该参数是⼀个输出型参数，由操作系统填充。
如果传递NULL，表⽰不关⼼⼦进程的退出状态信息。
否则，操作系统会根据该参数，将⼦进程的退出信息反馈给⽗进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16⽐特位）：

进程的阻塞等待⽅式：

int main()
{
	 pid_t pid;
	 pid = fork();
	 if(pid < 0)
	 {
	 	printf("%s fork error\n",__FUNCTION__);
	 	return 1;
	 } 
	 else if( pid == 0 )
	 { //child
	 	printf("child is run, pid is : %d\n",getpid());
	 	sleep(5);
	 	exit(257);
	 } 
	 else
	 {
	 	int status = 0;
	 	pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S 
		printf("this is test for wait\n");
		if( WIFEXITED(status) && ret == pid )
		{
			printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
		}
		else
		{
			printf("wait child failed, return.\n");
			return 1;
	 	}
	 }
	 return 0;
}
运⾏结果:
[root@localhost linux]# ./a.out
child is run, pid is : 45110
this is test for wait
wait child 5s success, child return code is :1.

进程的⾮阻塞等待⽅式：

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>
typedef void (*handler_t)(); // 函数指针类型 
std::vector<handler_t> handlers; // 函数指针数组 
void fun_one() 
{
 printf("这是⼀个临时任务1\n");
}
void fun_two() 
{
 printf("这是⼀个临时任务2\n");
}
void Load() 
{
 	handlers.push_back(fun_one);
 	handlers.push_back(fun_two);
}
void handler() 
{
 	if (handlers.empty())
 	Load();
 	for (auto iter : handlers)
 	iter();
}
int main() 
{
	 pid_t pid;
	 pid = fork();
	 if (pid < 0) 
	 {
	 	printf("%s fork error\n", __FUNCTION__);
	 	return 1;
	 } 
	 else if (pid == 0) 
	 { // child
		 printf("child is run, pid is : %d\n", getpid());
		 sleep(5);
		 exit(1);
	 } 
	 else 
	 {
		 int status = 0;
		 pid_t ret = 0;
		 do 
		 {
		 	ret = waitpid(-1, &status, WNOHANG); // ⾮阻塞式等待 
			if (ret == 0) 
			{
			 	printf("child is running\n");
		 	}
			 handler();
	 	} while (ret == 0);
		 if (WIFEXITED(status) && ret == pid) 
		 {
		 	printf("wait child 5s success, child return code is :%d.\n",
		 	WEXITSTATUS(status));
		 } 
		 else 
		 {
		 	printf("wait child failed, return.\n");
		 	return 1;
		 }
	 }
 return 0;
}