Linux进程控制方式_Linux

1.进程创建

fork函数

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

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

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

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

fork之后，谁先执行完全由调度器决定！！！

fork的常规用法

1.一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。

2.一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

2.写时拷贝

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

具体见下图：

为什么要有写时拷贝？

1.因为有写时拷贝技术的存在，父子进程得以彻底分离，保证了进程独立性。

2.写时拷贝是一种延迟申请技术，可以提高整机内存的使用率。

3.进程终止

进程退出的场景

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

进程常见退出方法

1.正常终止（可以通过 echo $? 查看进程退出码）

从main返回
调用exit
调用_exit

2.异常退出

ctrl + c,信号终止

_exit 函数

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

参数： status 定义了进程的终止状态，父进程通过 wait 来获取该值

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

exit 函数

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]#

通过上边的例子，我们看到当printf中的字符串后边没有加 \n 时，调用exit函数会打印出字符串内容，但是调用 _exit 函数并不会打印任何内容，原因就是因为 exit 底层调用的是 _exit，exit在调用_exit之前，会刷新缓冲区，表现为原来缓冲区中的字符串被打印出来，但是 _exit并不会刷新缓冲区。

那么这个所谓的“缓冲区”在哪里呢？谁来维护的？

一定不在操作系统内部！！如果是操作系统维护的，缓冲区内的内容也能被 _exit 刷新来。

c标准库给我们维护的！！！

退出码

int main()
{
	int i;
	for(i=0;i<150;i++)
	{
		printf("%d: %s\n",i,strerror(i));
	}

	return 0;
}

通过上图，可以看出，一共有134个退出码。

4.进程等待

进程等待的必要性

1.之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。

2.另外，进程一旦变成僵尸状态，那就刀枪不入，“杀.人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。

3.最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。

4.父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

进程等待的方法

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:

wnohang: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的id。

注意：

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

说明：

1.wait和waitpid是系统调用！！！
2. 父进程等待子进程，当子进程执行 return / exit / _exit / 因为某种原因异常崩溃退出后，子进程会将自己的退出码信息写入自己的进程控制块（task_struct）中，此时，退出后的子进程处于z状态，此时代码可以释放，但是task_struct必须维护，直到父进程读取信息完毕后，子进程的task_struct才能释放。
3.父进程通过 wait / waitpid 传递的参数，就可以拿到子进程的退出结果（退出码等信息）。

验证上边说到的 “子进程会将自己的退出码信息写入到自己的进程控制块中” ：

获取子进程status

1.wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。

2.如果传递null，表示不关心子进程的退出状态信息。

3.否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

4.status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

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

int main()
{
	pid_t id=fork();
	if(id==0)
	{
		int cnt=5;
		while(cnt--)
		{
			printf("我是子进程，pid: %d,ppid(): %d\n",getpid(),getppid());
		}
		exit(100);
	}
	else if(id>0)
	{
			printf("我是父进程，pid: %d,ppid: %d\n",getpid(),getppid());
		int status=0;
		pid_t result = waitpid(-1,&status,0);
		if(result>0)
		{
            //printf("等待子进程成功，status: %d\n",status>>8);
			printf("等待子进程成功，status: %d\n",status>>8 & 0xffff);
		}
	}
	else
	{
		//fork error
	}
	return 0;
}

注意：获取status时，一定要先右移8位再按位与0xffff,如果不这么做的话，结果为：

显然与100不符，结果错误。（这就是为什么要将status右移8位再按位与0xffff）

将status右移8位再按位与0xffff后，结果为：

与100符合，结果正确。

当然，还有别的方法，将 status>>8 & 0xffff 改为 wexitstatus(status)。

5.进程程序替换

替换原理

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