【Linux】进程控制

进程创建

fork函数

在进行进程创建中通常有两种方式：
1️⃣：命令行启动命令（程序、指令等）
2️⃣：通过程序自身，fork出来子进程（所有fork出来的子进程，以父进程为模板，很多数据、代码继承子进程）
首先介绍fork函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程

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

进程调用fork，当控制转移到内核中的fork代码后，内核做：
1️⃣分配新的内存块和内核数据结构给子进程
2️⃣将父进程部分数据结构内容拷贝至子进程
3️⃣添加子进程到系统进程列表中
4️⃣fork返回后，开始调度器调度

当一个进程调用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

❓：fork函数为什么要给子进程返回0，给父进程返回子进程的PID？

🔈：一个父进程可以创建多个子进程，而一个子进程只能有一个父进程。因此，对于子进程来说，父进程是不需要被标识的；而对于父进程来说，子进程是需要被标识的，因为父进程创建子进程的目的是让其执行任务的，父进程只有知道了子进程的PID才能很好的对该子进程指派任务。

❓：为什么fork函数有两个返回值？

🔈：父进程调用fork函数后，为了创建子进程，fork函数内部将会进行一系列操作，包括创建子进程的进程控制块、创建子进程的进程地址空间、创建子进程对应的页表等等。子进程创建完毕后，操作系统还需要将子进程的进程控制块添加到系统进程列表当中，此时子进程便创建完毕了。也就是说，在fork函数内部执行return语句之前，子进程就已经创建完毕了，那么之后的return语句不仅父进程需要执行，子进程也同样需要执行，这就是fork函数有两个返回值的原因。

写时拷贝

👀：当子进程刚刚被创建时，子进程和父进程的数据和代码是共享的，即父子进程的代码和数据通过页表映射到物理内存的同一块空间。只有当父进程或子进程需要修改数据时，才将父进程的数据在内存当中拷贝一份，然后再进行修改。
🔥：通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。

💥：这种在需要进行数据修改时再进行拷贝的技术，称为写时拷贝技术。

🔒：为什么数据要进行写时拷贝？

🔑：进程具有独立性。多进程运行，需要独享各种资源，多进程运行期间互不干扰，不能让子进程的修改影响到父进程。保证父子进程的独立性。
🔈：注意：
1️⃣：所有的数据，父进程和子进程是不会都进行写入的，不需要写入修改的数据拷贝是没有意义的，浪费内存和系统资源。
2️⃣：fork时，要创建数据结构，如果还要将数据拷贝一份，fork的效率是会降低的。
3️⃣：fork本身就是向系统要更多的资源，要更多的资源和要更少的资源，哪一个更容易导致fork失败呢？当然是要更多资源了。

fork常规用法

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

fork调用失败原因

1️⃣：系统中有太多的进程
2️⃣：实际用户的进程数超过了限制

进程终止

进程退出场景

👉代码跑完，结果正确。退出码0
👉代码跑完，结果不正确。逻辑没问题，但是没有导致程序崩溃。退出码！0
👉代码没有运行完毕，程序崩溃了。

进程退出常见方法

正常终止（可以通过 echo $? 查看进程退出码）：
1.从main返回
2. 调用exit
3. _exit

为何main中总是return 0 ？
代表进程退出，结果是否运行正确。0：成功。

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

exit函数：
#include <unistd.h>
void exit(int status);
exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

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

💥实例：

int main()
{
printf("hello");
exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
hello[root@localhost linux]#
int main()
{
printf("hello");
_exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
[root@localhost linux]#

异常退出：
ctrl + c，信号终止

总结：
1️⃣main函数的return是终止进程，非main函数的return不是终止进程，而是结束函数。
2️⃣任何函数的exit都表示，直接终止进程。
3️⃣ exit：在退出的时候，会进行后续资源处理，包括刷新缓冲区。
4️⃣_exit：在退出的时候，不会进行后续资源处理，直接终止进程。

❓站在OS角度，如何理解进程终止？
核心思想：归还资源
1.“释放”曾经为何管理进程所维护的所有的数据结构对象
2.释放程序代码和数据占用的内存空间
3.取消曾经该进程的连接关系

“释放”：不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个“数据结构的池”。

进程等待

进程等待必要性

👉回收僵尸进程，解决内存泄露。（子进程退出，父进程如果不读取子进程的退出信息，子进程就会变成僵尸进程，进而造成内存泄漏。）
👉需要获取子进程的运行结束状态。
👉尽量父进程要晚于子进程退出，可以规范化进行资源回收。
👉父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息 。

进程等待的方法

wait方法

等待任意一个子进程，当子进程退出，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);
⭕️返回值：
1️⃣当正常返回的时候waitpid返回收集到的子进程的进程ID；
2️⃣如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
3️⃣如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
⭕️参数：
🔴pid：
1️⃣Pid=-1,等待任一个子进程。与wait等效。
2️⃣Pid>0.等待其进程ID与pid相等的子进程。
🔴status:
1️⃣WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
2️⃣WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
🔴options:
1️⃣WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

获取子进程status

👉上述进程等待的方法所使用的两个函数wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统进行填充。
👉如果对status参数传入NULL，表示不关心子进程的退出状态信息。
👉否则，操作系统会通过该参数，将子进程的退出信息反馈给父进程。
👉status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特
位）

在status的低16比特位当中，高8位表示进程的退出状态，即退出码。进程若是被信号所杀，则低7位表示终止信号，而第8位比特位是core dump标志。

//根据status得到进程的退出码和退出信号：
exitCode = (status >> 8) & 0xFF; //退出码
exitSignal = status & 0x7F;      //退出信号

系统当中提供了两个宏来获取退出码和退出信号。

exitNormal = WIFEXITED(status);  //是否正常退出
exitCode = WEXITSTATUS(status);  //获取退出码

🔗当一个进程非正常退出时，说明该进程是被信号所杀，那么该进程的退出码也就没有意义了。

wait方法代码示例

💬例如，创建子进程后，父进程可使用wait函数一直等待子进程，直到子进程退出后读取子进程的退出信息。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
	pid_t id = fork();
	if(id == 0){
		//child
		int count = 10;
		while(count--){
			printf("I am child...PID:%d, PPID:%d\n", getpid(), getppid());
			sleep(1);
		}
		exit(0);
	}
	//father
	int status = 0;
	pid_t ret = wait(&status);
	if(ret > 0){
		//wait success
		printf("wait child success...\n");
		if(WIFEXITED(status)){
			//exit normal
			printf("exit code:%d\n", WEXITSTATUS(status));
		}
	}
	sleep(3);
	return 0;
}

💬使用以下监控脚本对进程进行实时监控：

[sun@VM-0-3-centos lesson1]$ while :; do ps axj | head -1 && ps axj | grep proc | grep -v grep;echo "######################";sleep 1;done

💬这时我们可以看到，当子进程进行了10次打印退出后，父进程读取了子进程的退出信息，子进程也就不会变成僵尸进程了。父进程3秒之后也退出了。

waitpid方法代码示例

💬例如，创建子进程后，父进程可使用waitpid函数一直等待子进程（此时将waitpid的第三个参数设置为0），直到子进程退出后读取子进程的退出信息。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0){
		//child          
		int count = 10;
		while (count--){
			printf("I am child...PID:%d, PPID:%d\n", getpid(), getppid());
			sleep(1);
		}
		exit(0);
	}
	//father           
	int status = 0;
	pid_t ret = waitpid(id, &status, 0);
	if (ret >= 0){
		//wait success                    
		printf("wait child success...\n");
		if (WIFEXITED(status)){
			//exit normal                                 
			printf("exit code:%d\n", WEXITSTATUS(status));
		}
		else{
			//signal killed                              
			printf("killed by siganl %d\n", status & 0x7F);
		}
	}
	sleep(3);
	return 0;
}

在父进程运行过程中，我们可以尝试使用kill -9命令将子进程杀死，这时父进程也能等待子进程成功。

多进程创建及等待

💬例如，以下代码中同时创建了10个子进程，同时将子进程的pid放入到ids数组当中，并将这10个子进程退出时的退出码设置为该子进程pid在数组ids中的下标，之后父进程再使用waitpid函数指定等待这10个子进程。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	pid_t ids[10];
	for (int i = 0; i < 10; i++){
		pid_t id = fork();
		if (id == 0){
			//child
			printf("child process created successfully...PID:%d\n", getpid());
			sleep(3);
			exit(i); //将子进程的退出码设置为该子进程PID在数组ids中的下标
		}
		//father
		ids[i] = id;
	}
	for (int i = 0; i < 10; i++){
		int status = 0;
		pid_t ret = waitpid(ids[i], &status, 0);
		if (ret >= 0){
			//wait child success
			printf("wiat child success..PID:%d\n", ids[i]);
			if (WIFEXITED(status)){
				//exit normal
				printf("exit code:%d\n", WEXITSTATUS(status));
			}
			else{
				//signal killed
				printf("killed by signal %d\n", status & 0x7F);
			}
		}
	}
	return 0;
}

非阻塞式等待

💬上述所给例子中，当子进程未退出时，父进程都在一直等待子进程退出，在等待期间，父进程不能做任何事情，这种等待叫做阻塞等待。

💬实际上我们可以让父进程不要一直等待子进程退出，而是当子进程未退出时父进程可以做一些自己的事情，当子进程退出时再读取子进程的退出信息，即非阻塞等待。

💬向waitpid函数的第三个参数potions传入WNOHANG，这样一来，等待的子进程若是没有结束，那么waitpid函数将直接返回0，不予以等待。而等待的子进程若是正常结束，则返回该子进程的pid。

💬例如，父进程可以隔一段时间调用一次waitpid函数，若是等待的子进程尚未退出，则父进程可以先去做一些其他事，过一段时间再调用waitpid函数读取子进程的退出信息。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	pid_t id = fork();
	if (id == 0){
		//child
		int count = 3;
		while (count--){
			printf("child do something...PID:%d, PPID:%d\n", getpid(), getppid());
			sleep(3);
		}
		exit(0);
	}
	//father
	while (1){
		int status = 0;
		pid_t ret = waitpid(id, &status, WNOHANG);//非阻塞式等待
		if (ret > 0){
			printf("wait child success...\n");
			printf("exit code:%d\n", WEXITSTATUS(status));
			break;
		}
		else if (ret == 0){
			printf("father do other things...\n");
			sleep(1);
		}
		else{
			printf("waitpid error...\n");
			break;
		}
	}
	return 0;
}

运行结果就是，父进程每隔一段时间就去查看子进程是否退出，若未退出，则父进程先去忙自己的事情，过一段时间再来查看，直到子进程退出后读取子进程的退出信息。

进程替换

替换原理

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

❓当进行进程程序替换时，有没有创建新的进程？

⭐️进程程序替换之后，该进程对应的PCB、进程地址空间以及页表等数据结构都没有发生改变，只是进程在物理内存当中的数据和代码发生了改变，所以并没有创建新的进程，而且进程程序替换前后该进程的pid并没有改变。

❓子进程进行进程程序替换后，会影响父进程的代码和数据吗？

⭐️子进程刚被创建时，与父进程共享代码和数据，但当子进程需要进行进程程序替换时，也就意味着子进程需要对其数据和代码进行写入操作，这时便需要将父子进程共享的代码和数据进行写时拷贝，此后父子进程的代码和数据也就分离了，因此子进程进行程序替换后不会影响父进程的代码和数据。

替换函数

其实有六种以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[]);

命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。
👉l(list) : 表示参数采用列表
👉v(vector) : 参数用数组
👉p(path) : 有p自动搜索环境变量PATH
👉e(env) : 表示自己维护环境变量

exec调用举例

#include <unistd.h>
int main()
{
	char *const argv[] = {"ps", "-ef", NULL};
	char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
	execl("/bin/ps", "ps", "-ef", NULL);
	// 带p的，可以使用环境变量PATH，无需写全路径
	execlp("ps", "ps", "-ef", NULL);
	// 带e的，需要自己组装环境变量
	execle("ps", "ps", "-ef", NULL, envp);
	execv("/bin/ps", argv);
	// 带p的，可以使用环境变量PATH，无需写全路径
	execvp("ps", argv);
	// 带e的，需要自己组装环境变量
	execve("/bin/ps", argv, envp);
	exit(0);
}

事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册 第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。

函数解释

1️⃣这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
2️⃣如果调用出错则返回-1
3️⃣所以exec函数只有出错的返回值而没有成功的返回值。