详解Linux下多进程与多线程通信（二）

一.进程相关指令和概念

1.进程相关指令

1.ps ——— 查看进程信息ps aux ——— 显示系统所有的进程ps -elf  ———   显示系统所有的进程(通用)
2.top ————   动态查看进程信息
3.pstree ———— 查看父子关系结构的进程
4.kill -9 进程号   ———   杀死进程。(通过信号)

2.父子进程和进程ID

        Linux中的进程都是由其它进程启动。如果进程a启动了进程b, 所以称a是b的父进程, b是a的子进程。

        Linux启动时,0进程启动1号进程(init )和2号进程(内核线程), 0号进程退出, 其它进程是由1、2直接或间接产生。

        1号进程（init）是所有用户进程的祖先。

        2号进程（内核进程）是内核进程的祖先。

        Linux 系统下的每一个进程都有一个进程号（process ID，简称 PID），进程号是一个正数，用于唯一标识系统中的某一个进程。进程号的作用就是用于唯一标识系统中某一个进程，在某些系统调用中，进程号可以作为传入参数、有时也可作为返回值。譬如系统调用 kill()允许调用者向某一个进程发送一个信号，如何表示这个进程呢？则是通过进程号进行标识。

        相关函数：

        函数getpid() 获取本进程的ID函数getppid() 获取父进程的ID (get perent pid)

二.进程编程

1.fork()创建子进程

        一个现有的进程可以调用 fork()函数创建一个新的进程，调用 fork()函数的进程称为父进程，由 fork()函数创建出来的进程被称为子进程（child process）。fork()调用成功后，子进程和父进程会继续执行 fork()调用之后的指令，子进程、父进程各自在自己的进程空间中运行。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行 fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。

        fork()调用成功后，将会在父进程中返回子进程的 PID，而在子进程中返回值是 0；
虽然子进程是父进程的一个副本，但是对于程序代码段（文本段）来说，两个进程执行相同的代码段，因为代码段是只读的，也就是说父子进程共享代码段，在内存中只存在一份代码段数据。使用fork()函数创建子进程，如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{pid_t pid;pid = fork();switch (pid) {case -1:perror("fork error");exit(-1);case 0:printf("这是子进程打印信息<pid: %d, 父进程 pid: %d>\n",getpid(), getppid());_exit(0); //子进程使用_exit()退出default:printf("这是父进程打印信息<pid: %d, 子进程 pid: %d>\n",getpid(), pid);exit(0);}
}

        运行结果如下所示：

        fork()函数调用完成之后，父进程、子进程会各自继续执行 fork()之后的指令，最终父进程会执行到 exit()结束进程，而子进程则会通过_exit()结束进程。 

        fork()函数有以下两种用法：

        1.父进程希望子进程复制自己，使父进程和子进程同时执行不同的代码段。这在网络服务进程中是常见的，父进程等待客户端的服务请求，当接收到客户端发送的请求事件后，调用 fork()创建一个子进程，使子进程去处理此请求、而父进程可以继续等待下一个服务请求。

        2.一个进程要执行不同的程序。譬如在程序 app1 中调用 fork()函数创建了子进程，此时子进程是要去执行另一个程序 app2，也就是子进程需要执行的代码是 app2 程序对应的代码，子进程将从 app2程序的 main 函数开始运行。

2.vfork()系统调用

        vfork()系统调用，虽然在一些细节上有所不同，但其效率要高于 fork()函数。类似于 fork()，vfork()可以为调用该函数的进程创建一个新的子进程，然而，vfork()是为子进程立即执行新的程序而专门设计的，也就是 fork()函数的第二个使用场景。

        vfork()与fork()函数主要有以下两个区别：

        1.vfork()与 fork()一样都创建了子进程，但 vfork()函数并不会将父进程的地址空间完全复制到子进程中，因为子进程会立即调用 exec（或_exit），于是也就不会引用该地址空间的数据。不过在子进程调用 exec 或_exit 之前，它在父进程的空间中运行、子进程共享父进程的内存。这种优化工作方式的实现提高的效率；但如果子进程修改了父进程的数据（除了 vfork 返回值的变量）、进行了函数调用、或者没有调用 exec 或_exit 就返回将可能带来未知的结果。

        2.vfork()保证子进程先运行，子进程调用 exec 之后父进程才可能被调度运行。

        虽然 vfork()系统调用在效率上要优于 fork()，但是 vfork()可能会导致一些难以察觉的程序 bug，所以尽量避免使用 vfork()来创建子进程。

3.wait()函数

        有时设计需要监视子进程的终止时间以及终止时的一些状态信息，在某些设计需求下这是很有必要的。系统调用 wait()可以等待进程的任一子进程终止，同时获取子进程的终止状态信息。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main(void)
{int status;int ret;int i;/* 循环创建 3 个子进程 */for (i = 1; i <= 3; i++) {switch (fork()) {case -1:perror("fork error");exit(-1);case 0:/* 子进程 */printf("子进程<%d>被创建\n", getpid());sleep(i);_exit(i);default:/* 父进程 */break;}}sleep(1);printf("~~~~~~~~~~~~~~\n");for (i = 1; i <= 3; i++) {ret = wait(&status);if (-1 == ret) {if (ECHILD == errno) {printf("没有需要等待回收的子进程\n");exit(0);}else {perror("wait error");exit(-1);}}printf("回收子进程<%d>, 终止状态<%d>\n", ret,WEXITSTATUS(status));}exit(0);
}

        运行结果如下所示:

        通过 for 循环创建了 3 个子进程，父进程中循环调用 wait()函数等待回收子进程，并将本
次回收的子进程进程号以及终止状态打印出来，

4. 僵尸进程与孤儿进程

        当一个进程创建子进程之后，它们俩就成为父子进程关系，父进程与子进程的生命周期往往是不相同的， 有两种情况，父进程先于子进程结束，子进程先于父进程结束。

        孤儿进程：

        父进程先于子进程结束，也这种进程就称为孤儿进程。在 Linux 系统当中，所有的孤儿进程都自动成为 init 进程（进程号为 1）的子进程， 该子进程调用 getppid()将返回 1，init 进程变成了孤儿进程的“养父”。

        僵尸进程：

        进程结束之后，通常需要其父进程为其“收尸”，回收子进程占用的一些内存资源，父进程通过调用wait()（或其变体 waitpid()、waitid()等）函数回收子进程资源，归还给系统。如果子进程先于父进程结束，此时父进程还未来得及给子进程“收尸”，那么此时子进程就变成了一个僵尸进程。

5. execve()函数

        系统调用 execve()可以将新程序加载到某一进程的内存空间，通过调用 execve()函数将一个外部的可执行文件加载到进程的内存空间运行，使用新的程序替换旧的程序，而进程的栈、数据、以及堆数据会被新程序的相应部件所替换，然后从新程序的 main()函数开始执行。        

6.system()函数

        使用 system()函数可以很方便地在我们的程序当中执行任意 shell 命令。

8.进程状态与进程关系

        进程状态：

        Linux 系统下进程通常存在 6 种不同的状态，分为：就绪态、运行态、僵尸态、可中断睡眠状态（浅度睡眠）、不可中断睡眠状态（深度睡眠）以及暂停态。

        就绪态（Ready）：指该进程满足被 CPU 调度的所有条件但此时并没有被调度执行，只要得到 CPU就能够直接运行；意味着该进程已经准备好被 CPU 执行，当一个进程的时间片到达，操作系统调度程序会从就绪态链表中调度一个进程；

        运行态：指该进程当前正在被 CPU 调度运行，处于就绪态的进程得到 CPU 调度就会进入运行态；

        僵尸态：僵尸态进程其实指的就是僵尸进程，指该进程已经结束、但其父进程还未给它“收尸”；

        可中断睡眠状态：可中断睡眠也称为浅度睡眠，表示睡的不够“死”，还可以被唤醒，一般来说可以通过信号来唤醒；

        不可中断睡眠状态：不可中断睡眠称为深度睡眠，深度睡眠无法被信号唤醒，只能等待相应的条件成立才能结束睡眠状态。把浅度睡眠和深度睡眠统称为等待态（或者叫阻塞态），表示进程处于一种等待状态，等待某种条件成立之后便会进入到就绪态；所以，处于等待态的进程是无法参与进程系统调度的。

        暂停态：暂停并不是进程的终止，表示进程暂停运行，一般可通过信号将进程暂停，譬如 SIGSTOP信号；处于暂停态的进程是可以恢复进入到就绪态的，譬如收到 SIGCONT 信号。

        一个新创建的进程会处于就绪态，只要得到 CPU 就能被执行。以下列出了进程各个状态之间的转换关系，如下所示：       

        进程关系：

        无关系：两个进程间没有任何关系，相互独立。

        父子进程关系：两个进程间构成父子进程关系，譬如一个进程 fork()创建出了另一个进程，那么这两个进程间就构成了父子进程关系，

        进程组：每个进程除了有一个进程 ID、父进程 ID 之外，还有一个进程组 ID，用于标识该进程属于哪一个进程组，进程组是一个或多个进程的集合，这些进程并不是孤立的，它们彼此之间或者存在父子、兄弟关系，或者在功能上有联系。

9.守护进程

        守护进程是运行在后台的一种特殊进程，它独立于控制终端并且周期性地执行某种任务或等待处理某些事情的发生，主要表现为以下两个特点：

        长期运行：守护进程是一种生存期很长的一种进程，它们一般在系统启动时开始运行，除非强行终止，否则直到系统关机都会保持运行。与守护进程相比，普通进程都是在用户登录或运行程序时创建，在运行结束或用户注销时终止，但守护进程不受用户登录注销的影响，它们将会一直运行着、直到系统关机。

        与控制终端脱离：在 Linux 中，系统与用户交互的界面称为终端，每一个从终端开始运行的进程都会依附于这个终端。当控制终端被关闭的时候，该会话就会退出，由控制终端运行的所有进程都会被终止，这使得普通进程都是和运行该进程的终端相绑定的；但守护进程能突破这种限制，它脱离终端并且在后台运行，脱离终端的目的是为了避免进程在运行的过程中的信息在终端显示并且进程也不会被任何终端所产生的信息所打断。

三.线程编程

        线程是参与系统调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一个线程指的是进程中一个单一顺序的控制流（或者说是执行路线、执行流），一个进程中可以创建多个线程，多个线程实现并发运行，每个线程执行不同的任务。

        当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程（Main Thread），因为它是程序一开始时就运行的线程。应用程序都是以 main()做为入口开始运行的，所以 main()函数就是主线程的入口函数，main()函数所执行的任务就是主线程需要执行的任务。

        其他新的线程是由主线程创建的，主线程通常会在最后结束运行，执行各种清理工作，譬如回收各个子线程。

        在多线程应用程序中，通常一个进程中包括了多个线程，每个线程都可以参与系统调度、被 CPU 执行，线程具有以下一些特点：

        1.线程不单独存在、而是包含在进程中；

        2.线程是参与系统调度的基本单位；

        3.可并发执行。同一进程的多个线程之间可并发执行，在宏观上实现同时运行的效果；

        4.共享进程资源。同一进程中的各个线程，可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的地址空间（进程的地址空间），这意味着，线程可以访问该地址空间的每一个虚地址；此外，还可以访问进程所拥有的已打开文件、定时器、信号量等等。

1.创建线程

        启动程序时，创建的进程只是一个单线程的进程，称之为初始线程或主线程，主线程可以使用库函数 pthread_create()负责创建一个新的线程，创建出来的新线程被称为主线程的子线程，函数原型如下：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);//thread： pthread_t 类型指针，当 pthread_create()成功返回时，新创建的线程的线程 ID 会保存在参数thread所指向的内存中，后续的线程相关函数会使用该标识来引用此线程。
//attr：pthread_attr_t 类型指针，指向 pthread_attr_t 类型的缓冲区，pthread_attr_t 数据类型定义了线程的各种属性，如果将参数 attr 设置为 NULL，那么表示将线程的所有属性设置为默认值，以此创建新线程。
//start_routine：参数 start_routine 是一个函数指针，指向一个函数，新创建的线程从start_routine()函数开始运行，该函数返回值类型为 void *，并且该函数的参数只有一个 void *，其实这个参数就是 pthread_create()函数的第四个参数 arg。如果需要向 start_routine()传递的参数有一个以上，那么需要把这些参数放到一个结构体中，然后把这个结构体对象的地址作为 arg 参数传入。
//arg：传递给 start_routine()函数的参数。

        线程创建成功，新线程就会加入到系统调度队列中，获取到 CPU 之后就会立马从 start_routine()函数开始运行该线程的任务；调用 pthread_create()函数后，通常我们无法确定系统接着会调度哪一个线程来使用CPU 资源。使用示例：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <unistd.h>
static void *new_thread_start(void *arg)
{printf("新线程: 进程 ID<%d> 线程 ID<%lu>\n", getpid(), pthread_self());return (void *)0;
}
int main(void)
{pthread_t tid;int ret;ret = pthread_create(&tid, NULL, new_thread_start, NULL);if (ret) {fprintf(stderr, "Error: %s\n", strerror(ret));exit(-1);}printf("主线程: 进程 ID<%d> 线程 ID<%lu>\n", getpid(), pthread_self());sleep(1);exit(0);
}

        结果如下：

2.终止线程运行的方式

        a.线程的 start 函数执行 return 语句并返回指定值，返回值就是线程的退出码；

        b.线程调用 pthread_exit()函数；

        c.调用 pthread_cancel()取消线程;

3.回收线程

        在父、子进程当中，父进程可通过 wait()函数（或其变体 waitpid()）阻塞等待子进程退出并获取其终止状态，回收子进程资源；而在线程当中，也需要如此，通过调用 pthread_join()函数来阻塞等待线程的终止，并获取线程的退出码，回收线程资源；

4.取消线程

        在通常情况下，进程中的多个线程会并发执行，每个线程各司其职，直到线程的任务完成之后，该线程中会调用 pthread_exit()退出，或在线程 start 函数执行 return 语句退出。有时候，在程序设计需求当中，需要向一个线程发送一个请求，要求它立刻退出，我们把这种操作称为取消线程。

        a.取消一个线程：通过调用 pthread_cancel()库函数向一个指定的线程发送取消请求，函数原型如下:       

int pthread_cancel(pthread_t thread);

        b.取消状态以及类型:默认情况下，线程是响应其它线程发送过来的取消请求的，响应请求然后退出线程。当然，线程可以选择不被取消或者控制如何被取消，通过 pthread_setcancelstate()和 pthread_setcanceltype()来设置线程的取消性状态和类型。

5.分离线程

        默认情况下，当线程终止时，其它线程可以通过调用 pthread_join()获取其返回状态、回收线程资源，有时，程序员并不关系线程的返回状态，只是希望系统在线程终止时能够自动回收线程资源并将其移除。在这种情况下，可以调用 pthread_detach()将指定线程进行分离，也就是分离线程，pthread_detach()函数原型如下所示：

int pthread_detach(pthread_t thread);