Linux进程控制 - 教程

1：创建进程

1：fork函数初识

在Linux中fork函数是非常重要的函数，他从已存在的进程中创建一个新的进程，新的进程是子进程，而原进程是父进程。

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

所以fork之前的父进程独立执行，fork之后，父进程分俩个流执行。注意，fork之后，谁先执行完全由调度器决定

2：fork函数的返回值

子进程返回0，

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

3：写时拷贝

通常，⽗⼦代码共享，⽗⼦再不写⼊时，数据也是共享的，当任意⼀⽅试图写⼊，便以写时拷⻉的式各⾃⼀份副本。

因为有写时拷贝技术的存在,所以⽗⼦进程得以彻底分离离！完成了进程独⽴性的技术保证!

写时拷贝,是⼀种延时申请技术,可以提⾼整机内存的使⽤率。

4：fork常规用法

1：⼀个⽗进程希望复制⾃⼰，使⽗⼦进程同时执⾏不同的代码段。例如，⽗进程等待客⼾端请求，⽣成⼦进程来处理请求。

2：⼀个进程要执⾏⼀个不同的程序。例如⼦进程从fork返回后，调⽤exec函数。

5：fork调用失败原因

1：系统中有太多进程

2：实际用户的进程数超过了限制

2：进程终止

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

1：进程退出场景

代码运⾏完毕，结果正确

代码运⾏完毕，结果不正确

代码异常终⽌

2：进程常见退出方法

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

1. 从main返回

2. 调⽤exit

3. _exit

异常退出：

ctrl + c，信号终⽌

1：退出码

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

退出码 0 表⽰命令执⾏⽆误，这是完成命令的理想状态。

退出码 1 我们也可以将其解释为 “不被允许的操作”。例如在没有 sudo 权限的情况下使⽤

yum；再例如除以 0 等操作也会返回错误码 1 ，对应的命令为 let a=1/0

130 （ SIGINT 或 ^C ）和 143 （ SIGTERM ）等终⽌信号是⾮常典型的，它们属于

128+n 信号，其中 n 代表终⽌码。

可以使⽤strerror函数来获取退出码对应的描述。

2：exit函数

#include
void exit(int status);

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

1：执行用户通过atexit或on_exit定义的清理函数

2：关闭所有打开的流，所有的缓存数据均被写入

3：调用_exit

3：return退出

return是一种更常见的退出进程的方法。执行return n等同于执行exit(n)，因为调用main的运行时函数会将main的返回值当做exit的参数

3：进程等待

1：进程等待的必要性

之前讲过，⼦进程退出，⽗进程如果不管不顾，就可能造成‘僵⼫进程’的问题，进⽽造成内存

泄漏。

另外，进程⼀旦变成僵⼫状态，那就⼑枪不⼊，“杀⼈不眨眼”的kill -9 也⽆能为⼒，因为谁也

没有办法杀死⼀个已经死去的进程。

最后，⽗进程派给⼦进程的任务完成的如何，我们需要知道。如，⼦进程运⾏完成，结果对还是

不对，或者是否正常退出。

⽗进程通过进程等待的⽅式，回收⼦进程资源，获取⼦进程退出信息

2：进程等待的方法

1：wait方法

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

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:默认为0，表⽰阻塞等待
WNOHANG: 若pid指定的⼦进程没有结束，则waitpid()函数返回0，不予以等
待。若正常结束，则返回该⼦进程的ID。

如果⼦进程已经退出，调⽤wait/waitpid时，wait/waitpid会⽴即返回，并且释放资源，获得⼦

进程退出信息。

如果在任意时刻调⽤wait/waitpid，⼦进程存在且正常运⾏，则进程可能阻塞。

如果不存在该⼦进程，则⽴即出错返回。

 3：获取子进程status

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

如果传递NULL，表⽰不关⼼⼦进程的退出状态信息。

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

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

⽐特位）：

4：进程程序替换

fork() 之后,⽗⼦各⾃执⾏⽗进程代码的⼀部分如果⼦进程就想执⾏⼀个全新的程序呢？进程的程序

替换来完成这个功能！程序替换是通过特定的接⼝，加载磁盘上的⼀个全新的程序(代码和数据）加载到调⽤进程的地址空间中！

1：替换原理

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

2：替换函数

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

#include 
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[]);

1：函数解释

这些函数如果调⽤成功则加载新的程序从启动代码开始执⾏,不再返回。

如果调⽤出错则返回-1

所以exec函数只有出错的返回值⽽没有成功的返回值。

2：命名理解

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