[TOC] # 并行和并发 **并行(parallel)：** 指在同一时刻，有多条指令在多个处理器上同时执行。 **并发(concurrency)：** 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 # MMU MMU是Memory Management Unit的缩写，中文名是[内存管理](https://baike.baidu.com/item/%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86)单元，它是[中央处理器](https://baike.baidu.com/item/%E4%B8%AD%E5%A4%AE%E5%A4%84%E7%90%86%E5%99%A8)（CPU）中用来管理[虚拟存储器](https://baike.baidu.com/item/%E8%99%9A%E6%8B%9F%E5%AD%98%E5%82%A8%E5%99%A8)、物理存储器的控制线路，同时也负责[虚拟地址](https://baike.baidu.com/item/%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80)映射为[物理地址](https://baike.baidu.com/item/%E7%89%A9%E7%90%86%E5%9C%B0%E5%9D%80)，以及提供硬件机制的内存访问授权，多用户多进程操作系统。  # 进程控制块PCB 进程运行时，内核为进程每个进程分配一个PCB（进程控制块），维护进程相关的信息，Linux内核的进程控制块是task\_struct结构体。 在 /usr/src/linux-headers-xxx/include/linux/sched.h 文件中可以查看struct task\_struct 结构体定义： > $ cat /usr/src/linux-headers-4.10.0-28/include/linux/sched.h  其内部成员有很多，我们掌握以下部分即可： * 进程id。系统中每个进程有唯一的id，在C语言中用pid\_t类型表示，其实就是一个非负整数。 * 进程的状态，有就绪、运行、挂起、停止等状态。 * 进程切换时需要保存和恢复的一些CPU寄存器。 * 描述虚拟地址空间的信息。 * 描述控制终端的信息。 * 当前工作目录（Current Working Directory）。 * umask掩码。 * 文件描述符表，包含很多指向file结构体的指针。 * 和信号相关的信息。 * 用户id和组id。 * 会话（Session）和进程组。 * 进程可以使用的资源上限（Resource Limit） # 进程状态 进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。 在三态模型中，进程状态分为三个基本状态，即**运行态，就绪态，阻塞态**。 在五态模型中，进程分为**新建态、终止态，运行态，就绪态，阻塞态**。  **①TASK\_RUNNING：** 进程正在被CPU执行。当一个进程刚被创建时会处于TASK\_RUNNABLE，表示己经准备就绪，正等待被调度。 **②TASK\_INTERRUPTIBLE（可中断）：**进程正在睡眠（也就是说它被阻塞）等待某些条件的达成。一旦这些条件达成，内核就会把进程状态设置为运行。处于**此状态的进程也会因为接收到信号而提前被唤醒**，**比如给一个TASK\_INTERRUPTIBLE状态的进程发送SIGKILL信号，这个进程将先被唤醒（进入TASK\_RUNNABLE状态），然后再响应SIGKILL信号而退出**（变为TASK\_ZOMBIE状态），并不会从TASK\_INTERRUPTIBLE状态直接退出。 **③TASK\_UNINTERRUPTIBLE（不可中断）：** 处于等待中的进程，待资源满足时被唤醒，**但不可以由其它进程通过信号或中断唤醒**。由于不接受外来的任何信号，**因此无法用kill杀掉这些处于该状态的进程**。而**TASK\_UNINTERRUPTIBLE状态存在的意义就在于**，**内核的某些处理流程是不能被打断的**。如果响应异步信号，程序的执行流程中就会被插入一段用于处理异步信号的流程，于是原有的流程就被中断了，这可能使某些设备陷入不可控的状态。处于TASK\_UNINTERRUPTIBLE状态一般总是非常短暂的，通过ps命令基本上不可能捕捉到。 **④TASK\_ZOMBIE（僵死）：** 表示进程已经结束了，**但是其父进程还没有调用wait4或waitpid()来释放进程描述符**。为了父进程能够获知它的消息，子进程的进程描述符仍然被保留着。一旦父进程调用了wait4()，进程描述符就会被释放。 **⑤TASK\_STOPPED（停止）：** 进程停止执行。当进程接收到SIGSTOP，SIGTSTP，SIGTTIN，SIGTTOU等信号的时候。此外，**在调试期间接收到任何信号**，都会使进程进入这种状态。**当接收到SIGCONT信号，会重新回到TASK\_RUNNABLE**。 如何查看进程状态：  stat中的参数意义如下： | **参数** | **含义** | | --- | --- | | D | 不可中断 Uninterruptible（usually IO） | | R | 正在运行，或在队列中的进程 | | S(大写) | 处于休眠状态 | | T | 停止或被追踪 | | Z | 僵尸进程 | | W | 进入内存交换（从内核2.6开始无效） | | X | 死掉的进程 | | < | 高优先级 | | N | 低优先级 | | s | 包含子进程 | | + | 位于前台的进程组 | # 进程号和相关函数 每个进程都由一个进程号来标识，其类型为 pid\_t（整型），进程号的范围：0～32767。进程号总是唯一的，但进程号可以重用。当一个进程终止后，其进程号就可以再次使用。 接下来，再给大家介绍三个不同的进程号。 **进程号（PID）**： 标识进程的一个非负整型数。 **父进程号（PPID）**： 任何进程（ 除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。如，A 进程创建了 B 进程，A 的进程号就是 B 进程的父进程号。 **进程组号（PGID）**： 进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID） 。这个过程有点类似于 QQ 群，组相当于 QQ 群，各个进程相当于各个好友，把各个好友都拉入这个 QQ 群里，主要是方便管理，特别是通知某些事时，只要在群里吼一声，所有人都收到，简单粗暴。但是，这个进程组号和 QQ 群号是有点区别的，默认的情况下，当前的进程号会当做当前的进程组号。 **getpid函数** ~~~ #include <sys/types.h> #include <unistd.h> ​ pid_t getpid(void); 功能： 获取本进程号（PID） 参数： 无 返回值： 本进程号 ~~~ **getppid函数** ~~~ #include <sys/types.h> #include <unistd.h> ​ pid_t getppid(void); 功能： 获取调用此函数的进程的父进程号（PPID） 参数： 无 返回值： 调用此函数的进程的父进程号（PPID） ~~~ **getpgid函数** ~~~ #include <sys/types.h> #include <unistd.h> ​ pid_t getpgid(pid_t pid); 功能： 获取进程组号（PGID） 参数： pid：进程号 返回值： 参数为 0 时返回当前进程组号，否则返回参数指定的进程的进程组号 ~~~ 示例程序: ~~~ int main() { pid_t pid, ppid, pgid; ​ pid = getpid(); printf("pid = %d\n", pid); ​ ppid = getppid(); printf("ppid = %d\n", ppid); ​ pgid = getpgid(pid); printf("pgid = %d\n", pgid); ​ return 0; } ~~~ # 进程创建 系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。 ~~~ #include <sys/types.h> #include <unistd.h> ​ pid_t fork(void); 功能： 用于从一个已存在的进程中创建一个新进程，新进程称为子进程，原进程称为父进程。 参数： 无 返回值： 成功：子进程中返回 0，父进程中返回子进程 ID。pid_t，为整型。 失败：返回-1。 失败的两个主要原因是： 1）当前的进程数已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN。 2）系统内存不足，这时 errno 的值被设置为 ENOMEM。 ~~~ 示例代码 ~~~ int main() { fork(); printf("id ==== %d\n", getpid()); // 获取进程号 ​ return 0; } ~~~ 从运行结果，我们可以看出，fork() 之后的打印函数打印了两次，而且打印了两个进程号，这说明，fork() 之后确实创建了一个新的进程，新进程为子进程，原来的进程为父进程。 ## 区分父子进程 子进程是父进程的一个复制品，可以简单认为父子进程的代码一样的。那大家想过没有，这样的话，父进程做了什么事情，子进程也做什么事情（如上面的例子），是不是不能实现满足我们实现多任务的要求呀，那我们是不是要想个办法区别父子进程呀，这就通过 fork() 的返回值。 fork() 函数被调用一次，但返回两次。两次返回的区别是：子进程的返回值是 0，而父进程的返回值则是新子进程的进程 ID ~~~ int main() { pid_t pid; pid = fork(); if (pid < 0) { // 没有创建成功 perror("fork"); return 0; } ​ if (0 == pid) { // 子进程 while (1) { printf("I am son\n"); sleep(1); } } else if (pid > 0) { // 父进程 while (1) { printf("I am father\n"); sleep(1); } } ​ return 0; } ~~~ 通过运行结果，可以看到，父子进程各做一件事（各自打印一句话）。这里，我们只是看到只有一份代码，实际上，fork() 以后，有两个地址空间在独立运行着，有点类似于有两个独立的程序（父子进程）在运行着。 一般来说，在 fork() 之后是父进程先执行还是子进程先执行是不确定的。这取决于内核所使用的调度算法。 需要注意的是，在子进程的地址空间里，子进程是从 fork() 这个函数后才开始执行代码  ## 父子进程地址空间 ~~~ int a = 10; // 全局变量 ​ int main() { int b = 20; //局部变量 pid_t pid; pid = fork(); if (pid < 0) { // 没有创建成功 perror("fork"); } ​ if (0 == pid) { // 子进程 a = 111; b = 222; // 子进程修改其值 printf("son: a = %d, b = %d\n", a, b); } else if (pid > 0) { // 父进程 sleep(1); // 保证子进程先运行 printf("father: a = %d, b = %d\n", a, b); } ​ return 0; } ~~~ 通过得知，在子进程修改变量 a，b 的值，并不影响到父进程 a，b 的值。 # GDB调试多进程 ~~~ gcc -9 源码 ~~~ 使用gdb调试的时候，gdb只能跟踪一个进程。可以在fork函数调用之前，通过指令设置gdb调试工具跟踪父进程或者是跟踪子进程。默认跟踪父进程。 * set follow-fork-mode child 设置gdb在fork之后跟踪子进程。 * set follow-fork-mode parent 设置跟踪父进程（默认）。 注意，一定要在gdb中的fork函数调用之前设置才有效。 # 进程退出函数 ~~~ #include <stdlib.h> void exit(int status); ​ #include <unistd.h> void _exit(int status); 功能： 结束调用此函数的进程。 参数： status：返回给父进程的参数（低 8 位有效），至于这个参数是多少根据需要来填写。 返回值： 无 ~~~ 用法是一样的，无非时所包含的头文件不一样，还有的区别就是：exit()属于标准库函数，`_exit()`属于系统调用函数。  # 等待子进程退出函数 在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块PCB的信息（包括进程号、退出状态、运行时间等）。 父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。 wait() 和 waitpid() 函数的功能一样，区别在于，wait() 函数会阻塞，waitpid() 可以设置不阻塞，waitpid() 还可以指定等待哪个子进程结束。 注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。 ## wait函数 ~~~ #include <sys/types.h> #include <sys/wait.h> ​ pid_t wait(int *status); 功能： 等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收该子进程的资源。 参数： status : 进程退出时的状态信息。 返回值： 成功：已经结束子进程的进程号 失败： -1 ~~~ 调用 wait() 函数的进程会挂起（阻塞），直到它的一个子进程退出或收到一个不能被忽视的信号时才被唤醒（相当于继续往下执行）。 若调用进程没有子进程，该函数立即返回；若它的子进程已经结束，该函数同样会立即返回，并且会回收那个早已结束进程的资源。 所以，wait()函数的主要功能为回收已经结束子进程的资源。 如果参数 status 的值不是 NULL，wait() 就会把子进程退出时的状态取出并存入其中，这是一个整数值（int），指出了子进程是正常退出还是被非正常结束的。 这个退出信息在一个 int 中包含了多个字段，直接使用这个值是没有意义的，我们需要用宏定义取出其中的每个字段。 **宏函数可分为如下三组：** 1) WIFEXITED(status) 为非0 → 进程正常结束 WEXITSTATUS(status) 如上宏为真，使用此宏 → 获取进程退出状态 (exit的参数) 2) WIFSIGNALED(status) 为非0 → 进程异常终止 WTERMSIG(status) 如上宏为真，使用此宏 → 取得使进程终止的那个信号的编号。 3) WIFSTOPPED(status) 为非0 → 进程处于暂停状态 WSTOPSIG(status) 如上宏为真，使用此宏 → 取得使进程暂停的那个信号的编号。 WIFCONTINUED(status) 为真 → 进程暂停后已经继续运行 ## waitpid函数 ~~~ #include <sys/types.h> #include <sys/wait.h> ​ pid_t waitpid(pid_t pid, int *status, int options); 功能： 等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。 ​ 参数： pid : 参数 pid 的值有以下几种类型： pid > 0 等待进程 ID 等于 pid 的子进程。 pid = 0 等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid 不会等待它。 pid = -1 等待任一子进程，此时 waitpid 和 wait 作用一样。 pid < -1 等待指定进程组中的任何子进程，这个进程组的 ID 等于 pid 的绝对值。 ​ status : 进程退出时的状态信息。和 wait() 用法一样。 ​ options : options 提供了一些额外的选项来控制 waitpid()。 0：同 wait()，阻塞父进程，等待子进程退出。 WNOHANG：没有任何已经结束的子进程，则立即返回。 WUNTRACED：如果子进程暂停了则此函数马上返回，并且不予以理会子进程的结束状态。（由于涉及到一些跟踪调试方面的知识，加之极少用到） 返回值： waitpid() 的返回值比 wait() 稍微复杂一些，一共有 3 种情况： 1) 当正常返回的时候，waitpid() 返回收集到的已经回收子进程的进程号； 2) 如果设置了选项 WNOHANG，而调用中 waitpid() 发现没有已退出的子进程可等待，则返回 0； 3) 如果调用中出错，则返回-1，这时 errno 会被设置成相应的值以指示错误所在，如：当 pid 所对应的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid() 就会出错返回，这时 errno 被设置为 ECHILD； ~~~ # 孤儿和僵尸进程 **孤儿进程** 父进程运行结束，但子进程还在运行（未运行结束）的子进程就称为孤儿进程（Orphan Process）。 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init 进程会循环地 wait() 它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init 进程就会代表党和政府出面处理它的一切善后工作。 因此孤儿进程并不会有什么危害。 **僵尸进程** 进程终止，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。 这样就会导致一个问题，如果进程不调用wait() 或 waitpid() 的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。 # 进程替换 可以通过 ./ 运行，让一个可执行程序成为一个进程。 但是，如果我们本来就运行着一个程序（进程），我们如何在这个进程内部启动一个外部程序，由内核将这个外部程序读入内存，使其执行起来成为一个进程呢？这里我们通过 exec 函数族实现。 exec 函数族，顾名思义，就是一簇函数，在 Linux 中，并不存在 exec() 函数，exec 指的是一组函数，一共有 6 个： ~~~ #include <unistd.h> extern char **environ; ​ int execl(const char *path, const char *arg, .../* (char *) NULL */); int execlp(const char *file, const char *arg, ... /* (char *) NULL */); int execle(const char *path, const char *arg, .../*, (char *) NULL, char * const envp[] */); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); int execvpe(const char *file, char *const argv[], char *const envp[]); ​ int execve(const char *filename, char *const argv[], char *const envp[]); ~~~ 其中只有 execve() 是真正意义上的系统调用，其它都是在此基础上经过包装的库函数。 exec 函数族的作用是根据指定的文件名或目录名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。 进程调用一种 exec 函数时，该进程完全由新程序替换，而新程序则从其 main 函数开始执行。因为调用 exec 并不创建新进程，所以前后的进程 ID （当然还有父进程号、进程组号、当前工作目录……）并未改变。exec 只是用另一个新程序替换了当前进程的正文、数据、堆和栈段（进程替换）。  **exec 函数族使用说明** exec 函数族的 6 个函数看起来似乎很复杂，但实际上无论是作用还是用法都非常相似，只有很微小的差别。  补充说明： | l(list) | 参数地址列表，以空指针结尾 | | --- | --- | | v(vector) | 存有各参数地址的指针数组的地址 | | p(path) | 按 PATH 环境变量指定的目录搜索可执行文件 | | e(environment) | 存有环境变量字符串地址的指针数组的地址 | exec 函数族与一般的函数不同，exec 函数族中的函数执行成功后不会返回， **而且，exec 函数族下面的代码执行不到**。 只有调用失败了，它们才会返回 -1，失败后从原程序的调用点接着往下执行