Linux进程控制

fork函数

在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

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

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

• 分配新的内存块和内核数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程
• 添加子进程到系统进程列表当中
  在此阶段，子进程已经被创建，所以有两个return，即fork有两个返回值。
• fork返回，开始调度器调度

---

如何理解fork返回之后，给父进程返回子进程pid，给子进程返回0？
对于父进程来说，它可能有很多子进程，所以要记录它不同的子进程，就给父进程返回子进程的pid，而对于子进程来说，它的父进程一定唯一，所以返回0.

---

输出：

如何理解同一个id值，怎么可能保存两个不同的值，让if 和else if同时执行？
fork之后，子进程是没有代码和数据的，他和父进程共享代码和数据。代码本身是只读的，不会影响。但是数据是会修改的。因此父子进程代码共享，数据各自必须想办法私有一份。

这运用到了写时拷贝，如果数据值是一样的，那我就不做处理，如果数据不一样，那我子进程要想办法深拷贝一份数据，当子进程的值覆盖上去，这就完成了父子进程数据各自一份。
正是由于返回的时候发生了写时拷贝，因此同一个变量会有不同的值。

fork之后，子进程和父进程谁先执行呢？
首先，fork创建完成子进程，这仅仅是一个开始，创建完成后，系统的其他进程，还有当前的父进程和子进程，是要被CPU调度执行的。

当父子进程的PCB都被创建并在运行队列中排队的时候，哪一个进程先被CPU调度，哪一个进程就先运行，因此我们不确定，这是由各自PCB的调度信息（时间片，优先级等）+调度算法自助决定。

---

写时拷贝

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

当一个进程尝试修改数据时，虚拟地址不会改变，但是在物理内存中的地址会改变，这是通过进程的独立性和页表映射做到的。
代码证明：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 0;
int main()
{
 pid_t id = fork();
 if(id < 0){
 perror("fork");
 return 0;
 }
 else if(id == 0){ //child,子进程肯定先跑完，也就是子进程先修改，完成之后，父进程再读取
 g_val=100;
 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }else{ //parent
 sleep(3);
 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }
 sleep(1);
 return 0;
}

输出结果：

//与环境相关，观察现象即可
child[3046]: 100 : 0x80497e8
parent[3045]: 0 : 0x80497e8

我们发现，父子进程，输出地址是一致的，但是变量内容不一样！

进程终止

进程退出场景

1. 代码运行完毕，结果正确
2. 代码运行完毕，结果不正确
3. 代码异常终止
   其中1和2我们可以通过退出码判断。当退出码为0时通常表示结果正确，否则表示错误，而且不同的退出码表示不同的错误。
   3通过退出信号判断，而且当3发生时，退出码无意义。
   
   通过echo $?可以查看最近退出进程的退出码
   
   可以看到退出码为1，表示退出错误，我们可以发现求和函数有问题。

而当我们再次echo $?时

可以看到退出码为0，因为我们查看的时上次echo $?的退出码

另外，我们可以通过c语言库函数查看不同的退出码代表的退出信息

其实，linux指令也是用c语言写的，我们可以通过echo $?查看Linux指令使用的退出信息。
比如：

进程退出常见方法

正常终止：

• 从main中的return返回
• 任意位置调用exit
• _exit

_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之前，还做了其他工作：

1. 执行用户通过 atexit或on_exit定义的清理函数。
2. 关闭所有打开的流，所有的缓存数据均被写入
3. 调用_exit
   exit和_exit区别：
   exit会先刷新缓冲区在退出进程，而_exit不会，_exit是系统调用，exit底层也是调用的_exit，
   因此我们可以知道缓冲区是用户级别的，而不是系统级别的。
   其实main中的return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

异常退出：

• ctrl + c，信号终止
• kill信号终止

进程等待

进程等待的必要性：

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

进程等待的方法

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，子进程存在且正常运行，则进程可能阻塞。
如果不存在该子进程，则立即出错返回。

wait使用

我们可以分析一下此代码：
创建子进程，当子进程运行10s后变成僵尸进程，然后再过5s父进程开始等待子进程，此时直接等待成功。
我们可以再xshell通过查看进程状态，来验证这个过程。

---

waitpid和宏的使用

获取子进程status

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

其中次低8未表示退出状态即退出码，低7位表示退出信号。

---

再谈进程退出

1. 进程退出会变成僵尸，会把自己的退出结果写入刀自己的task_struct
2. wait/waitpid是一个系统调用 --> 操作系统也有资格也有能力区读取子进程的task_struct

进程task_struct的关于进程退出的信息

---

非阻塞等待

---

程序替换

替换原理

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

替换函数

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

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

• 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
• 如果调用出错则返回-1
• 当程序替换成功后，以前的代码和数据已经被替换，所以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);
}

我们可以通过程序替换，调用任何后端语言对应的可执行程序。

其实我们main函数中的参数就是通过execle系统调用传入的。

我们综合前面学的知识，可以制作一个简单的shell

考虑下面这个与shell典型的互动：

[root@localhost epoll]# ls
client.cpp readme.md server.cpp utility.h
[root@localhost epoll]# ps
 PID TTY TIME CMD
 3451 pts/0 00:00:00 bash
 3514 pts/0 00:00:00 ps

用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。