Linux进程控制

Merrill_hh

已于 2024-06-30 18:44:33 修改

阅读量727

点赞数 25

分类专栏： Linux学习文章标签： linux 学习 c语言

于 2024-05-13 16:26:06 首次发布

本文链接：https://blog.csdn.net/Merrill_Rosie/article/details/138808057

版权

Linux学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Linux进程控制

1. 进程创建
- 1.1 fork函数
- 1.2 写时拷贝
2. 进程终止
- 2.1 进程退出场景
- 2.2 进程常见退出方法
3. 进程等待
4. 进程程序替换

1. 进程创建

1.1 fork函数

（fork函数的初识已经在Linux概念篇介绍过啦）可以跳转：

这里：Linux进程概念

1.2 写时拷贝

当父进程形成子进程后，要发生写时拷贝，并重新申请空间、进行拷贝、修改页表，这些工作都要操作系统来做。

但是子进程此时正在进行写入，操作系统应该找个什么样的时机进行写时拷贝才合适呢？

父进程创建子进程的时，首先将自己的读写（数据段）权限改成只读，然后再创建子进程！作为用户是不知道这个过程的，所以在这个过程中用户可能对某一批数据进行写入！然后页表转换会因为权限问题出错，此时操作系统就可以介入了。

这里的出错分为两种情况：第一种是真的出错了，例如越界等；第二种不是真的出错，本来数据段属于可以写入，但是因为写时拷贝修改了权限而出错，这是会触发我们进行重新申请内存拷贝内容的策略机制。

这个操作就称之为写时拷贝

通常，父子代码共享，父子在不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本，实现子进程与父进程的一种惰性分离。具体见下图：

2. 进程终止

2.1 进程退出场景

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

在多进程环境中，父进程创建子进程的目的是为了帮助父进程办事，那么如何知道子进程把事办的怎么样？通俗的来讲就是如何知道代码是因为什么情况的而终止的？
可以通过main函数的返回值来知道结果如何：

0表示成功。
!0表示失败。当失败时，最关心的是这个进程是由什么原因引起的失败，此时就可以用非0的自然数表示各种失败的原因了！这些具体数字是什么含义可以由我们人为的去定义的，但是不便于我们程序猿直接阅读，所以需要有将错误码转换成错误字符串的描述方案。

系统为我们提供了这个方案，就是strerror，使用man手册查看一下：

这是C语言内置的出错码，如果不想用，我们还可以自定义出错码

那么Linux中到底为我们内置了多少退出码呢？我们一测便知

#include <string.h>
#include <stdio.h>
int main()
{
	int i = 0;
	for (; i < 200; ++i)
	{
		printf("%d:%s", i, strerror(i));
	}
	return 0;
}

QQ截图20240503172341

（好长好长T^T）这就是main函数的退出码，可以看到，退出码在133之后就识别不出来了，说明系统为我们提供了133个错误返回的退出码，1个正确返回的退出码。

上面我们提到亦可以自定义错误码，方法如下：

// 全局变量
const char *err_string[] = {
	"Success",
	"oper err",
	"other err"
};

C语言的错误码errno，使用方法：

#include <stdio.h>
#include <errno.h>
#include <string.h>
int main()
{
	printf("before:%d\n", errno);
	FILE *fp = fopen("./test.txt", "r");
	printf("after:%d,error string:%s\n", errno, strerror(errno));
	return 0;
}

运行结果：

错误码vs退出码：

错误码通常是衡量一个库函数、一个系统调用或者是一个函数调用的情况；
退出码通常是一个进程退出时，他的退出结果。

它们虽然是不同的东西，但是有共同的表征：当失败的时候，用来衡量函数或者进程出错时的详细出错原因。

所以错误码和退出码也可以这样去用：

int main()
{
	int ret = 0;
	printf("before:%d\n", errno);
	FILE *fp = fopen("./test.txt", "r");
	if (fp == NULL)
	{
		printf("after:%d,error string:%s\n", errno, strerror(errno));
		ret = errno;
	}
	return ret; // 让退出码返回错误码
}

2.2 进程常见退出方法

正常终止（可以通过echo $? 查看进程退出码，?保存的是最近一个子进程执行完毕的退出码）：

从main返回
调用exit
_exit

把退出码改成10

#include <string.h>
#include <stdio.h>
int main()
{
	int i = 0;
	for (; i < 200; ++i)
	{
		printf("%d:%s", i, strerror(i));
	}
	return 10;
}

当我们执行完毕多使用几次echo $?时，我们发现：

除了第一次的退出码是10以外，其他都是0。其实不难理解，因为该指令保存的是最近一个子进程执行完毕的退出码，退出码为10的进程执行完毕并且执行成功了，下个echo $?指令的退出码自然就是0了。

我们再次来查看一个不存在的文件

该命令和退出码所代表的含义再次得到很好的验证！
所以得到一个结论：

main函数的退出码是可以被父进程获取的，用来判断子进程的运行结果。

异常退出：

ctrl + c
kill -number pid信号终止

使用kill -l查看一下信号：

没有零号信号，零号表示没有收到信号。

先说一个结论：

当一个进程出现异常后，最终异常信息会被操作系统检测到，进而转换成信号然后被操作系统杀死了。所以，一个进程是否出异常，我们只需要看有没有收到信号即可！

如果有一个正常进程在运行中，我们发送对应的信号也会出现同样的报错信息。
比如，我想让这个进程产生浮点错误和段错误：

所以再次验证了上述的结论。
3. exit函数

使用man 3 exit查看一下exit函数

当exit函数在main函数的参数是进程的退出码时，与return n的作用相同。
但是与return不同的是，在任意地点调用exit都会使进程退出，不再执行后续的代码。exit终止的强度要return大很多。

_exit

使用man 2 exit或者man _exit查看一下_exit函数，在2号手册中说明是一个系统调用。

exit和_exit函数的区别

exit是库函数，_exit是系统调用
exit终止进程的时候，会自动刷新缓冲区。_exit终止进程的时候，不会自动刷新缓冲区。

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

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

所以可以知道，我们目前知道的缓冲区，绝对不再操作系统内部！而是属于C标准库内。

3. 进程等待

3.1 进程等待的概念

什么是进程等待？

通过wait/waitpid的方式，让父进程对子进程进行资源回收等待的过程。

为什么要进行进程等待？

之前讲过，子进程退出，父进程如果不管不顾，就可能造成僵尸进程的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，那就刀枪不入，”杀人不眨眼“的kill -9也无能为力，因为谁也没有办法杀死一个已经死去的进程。这是目前必须解决的问题。
最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息。（这不是进程等待所要必须解决的问题，但是系统需要提供这样的基础功能！）

3.2 进程等待的方法

使用man 2 wait查看一下

3.2.1 wait方法

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

关于wait：

进程等待能回收子进程的僵尸状态
如果子进程根本就没有退出，父进程必须在wait上进行阻塞等待，直到子进程变成僵尸进程，wait自动回收并返回！

首先用代码验证一下第一条

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
void Worker()
{
	int count = 5;
	while (count)
	{
		printf("I am a sub-process, pid:%d, ppid:%d, count:%d\n", getpid(), getppid(), count--);
		sleep(1);
	}
}
int main()
{
	pid_t id = fork();
	if (id == 0)
	{
		// child
		Worker();
		exit(0);
	}
	else
	{
        sleep(10);
		printf("wait before\n");
		pid_t rid = wait(NULL);
        printf("wait after\n");
		if (rid == id)
		{
			printf("wait success, pid:%d\n", getpid());
		}
		sleep(10);
	}
	return 0;
}

结果：

可以很清楚的看到，当子进程变为僵尸进程后，进程等待能回收子进程的僵尸状态。

再次验证第二条，将父进程中的sleep(10)注释掉：

在子进程没有退出时，父进程在wait上阻塞等待，当子进程退出时，一瞬间就被回收掉了（这里看不到变成Z状态再变成X状态的过程）。

一般而言，谁先运行不知道，但是一般都是父进程最后退出！

3.2.2 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:

WNOHANG：表示等待的时候，以非阻塞轮询方式等待。若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

关于waitpid：

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

3.3 获取子进程status

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

使用代码验证一下status：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
void Worker()
{
	int count = 5;
	while (count)
	{
		printf("I am a sub-process, pid:%d, ppid:%d, count:%d\n", getpid(), getppid(), count--);
		sleep(1);
	}
}
int main()
{
	pid_t id = fork();
	if (id == 0)
	{
		// child
		Worker();
		exit(10);
	}
	else
	{
		printf("wait before\n");
		int status = 0;
		pid_t wid = wait(id, &status, 0);
        printf("wait after\n");
		if (wid == id)
		{
			printf("wait success, pid:%d, wpid:%d, exit sign:%d, exit code:%d\n", getpid(), wid, status&0x7f, (status>>8)&0xff);
		}
		sleep(10);
	}
	return 0;
}

正常退出，退出信号为0，因为我们设置的退出码为10，所以退出码自然为10。

当一个进程异常了（收到信号），exit code（退出码）就无意义了。
0表示没有收到信号，!0表示收到信号。
如果手动杀掉该进程，依旧能收到与kill方法为之对应的信号。

我们为什么不用全局变量获取子进程的退出信息，而是用系统调用呢？

因为进程具有独立性，父进程无法直接获得子进程的退出信息。

3.4 非阻塞式等待代码模拟

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

void worker(int n)
{
	printf("I am a child, pid:%d, count:%d\n", getpid(), n);
}

int main()
{
	pid_t id = fork();
	if (id == 0)
	{
		// child
		int count = 10;
		while (count)
		{
			worker(count--);
			sleep(1);
		}
		exit(0);
	}
	// father
	while (1)
	{
		int status = 0;
        pid_t wid = waitpid(id, &status, WNOHANG);
        if (wid > 0)
        {
            // 等待成功，子进程已经退出
            printf("child quit successfully, exit code:%d, exit signal:%d\n", (status>>8)&0xff, status&0x7f);
            break;
        }
        else if (wid == 0)
        {
            // 等待成功，但是子进程没有退出
            printf("child is alive,father is doing other things...\n");
        }
        else // wid < 0
        {
            // 等待失败，子进程状态未知
            printf("wait failed!\n");
            break;
        }
        sleep(1);
    }
	return 0;
}

效果如下：

4. 进程程序替换

我们所创建的所有子进程执行的代码，都是父进程的一部分。但如果我们想让子进程执行新的程序或者执行全新的代码和访问全新的数据，并不再和父进程有任何的瓜葛呢？

这时候我们就需要用到一门技术——程序替换。

4.1 替换函数

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

#include <unistd.h>`
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

使用man手册查看一下exec函数：

（最后一个exec函数在2号手册，下面会提到）

4.2 替换原理

单进程版程序替换（没有子进程）

我们可以用“语言”调用其他程序
int execl(const char *path, const char *arg, ...);

const char *path表示我们要替换哪一个程序，找到程序文件的路径和文件名。
const char *arg表示该程序如何执行，也就是命令行怎么写，参数就怎么传递。
...必须以NULL结尾！！

举个栗子~

#include <stdio.h>
#include <unistd.h>
int main()
{
	printf("pid:%d, exec command begin!\n", getpid());
	execl("/usr/bin/ls", "ls", "-la", NULL);
	printf("pid:%d, exec command end!\n", getpid());
	return 0;
}

运行结果：

从运行结果可以看到，最后一条printf语句并没有执行，这是为什么捏？

exec这样的函数如果调用成功则加载新的程序从启动代码开始执行，后续代码不再执行并不再返回。
如果调用出错则返回-1。
所以exec函数只有失败的返回值而没有成功的返回值。

多进程版程序替换

#include <stdio.h>
#include <unistd.h>
int main()
{
	pid_t id = fork();
	if (id == 0)
	{
		// child
		printf("pid:%d, exec command begin!\n", getpid());
		sleep(5);
        execl("/usr/bin/ls", "ls", "-la", NULL);
        printf("pid:%d, exec command end!\n", getpid());
	}
	else
	{
		// father
		pid_t wid = waitpid(-1, NULL, 0);
		if (wid > 0)
		{
			printf("wait success, wid:%d\n", wid);
		}
	}
}

程序替换不创建子进程！

带环境变量的程序替换

当我们进程程序替换的时候，子进程对应的环境变量，是可以直接从父进程来的，父进程的环境从bash中来。

环境变量被子进程继承下去是一种默认行为，不受程序替换的影响。

这是因为通过地址空间可以让子进程继承父进程的环境变量数据，并且程序替换只会替换新程序的代码和数据，环境变量不会被替换！

说一下execle这个函数，int execle(const char *path, const char *arg, ..., char *const envp[]);

其中该函数中的最后一个参数，不是新增环境变量，而是覆盖式传递！

替换原理

用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。