# 进程

# 程序

  • 程序(Program)是一组可以被 CPU 执行的计算机指令。
    • 比如在 Windows 系统上双击启动一个软件、在 Linux 系统上执行一条命令,都是启动一个程序。
  • 程序被 CPU 执行时,主要分为以下几个阶段:
    • 启动 :开始执行。
    • 运行 :正在执行。
      • CPU 不一定会一直执行同一个程序,可能暂停执行它,转去执行其它程序,一段时间后再回来继续执行它。
    • 结束 :终止执行(不是暂停执行),并返回一个退出码。也称为程序退出、终止。
  • 程序终止的几种情况:
    • 执行完所有指令,正常退出。此时退出码为 0 。
    • 调用 exit() 函数,提前退出。此时退出码由程序决定。
    • 接收到 SIGTERM 等信号,被杀死。
  • 操作系统一般要求程序结束执行时返回一个整数值,称为退出码(Exit Code)、返回码(Return Code),用于表示程序的执行结果。
    • Shell 中程序退出码的取值范围为 0~255 ,通常取值为 0 时表示正常退出,取值为非 0 时表示异常退出。

# 进程

  • 进程(Process)是程序运行、分配系统资源的最小单位。
    • 启动一个程序时,至少要创建一个进程,来执行程序指令。
    • 当进程执行程序指令时,实际上是由进程中的线程,在 CPU 中执行。
  • 每个进程(称为父进程)可以创建任意个其它进程(称为子进程)。
    • 父进程及其所有子进程属于同一个进程组。
    • 当父进程终止时,内核并不会自动杀死其子进程。如果子进程依然保持运行,则称为孤儿进程(Orphan Process)。
      • Linux 系统会将出现的孤儿进程立即改为 init 进程的子进程,即 PPID 改为 1 ,被 init 进程管理。

# 进程组

:Process Group ,包含一个进程,或多个具有父子关系的进程。

  • 每个进程组中有且仅有一个 Leader 进程,是其它进程的父进程。

# 进程会话

:Process Session ,包含一个进程组,或多个具有父子关系的进程组。

  • 会话中的进程组又称为 job ,用于完成某种任务。
  • 一个 Session 中有且仅有一个 Leader 进程,是其它进程、进程组的根父进程。
    • 当 Session Leader 终止时,系统会给该 Session 的所有进程发送 SIGHUP 信号来终止它们。当 Session 中的所有进程都终止时,系统就会删除该 Session 。
  • 例如:用户登录时会创建一个 login shell ,还会创建一个 Session ,以 login shell 作为 Session Leader 。
    • 在该 Session 中,只有一个进程组能工作在前台,其它进程组都只能工作在后台。
    • 当用户登出时,属于该 Session 的所有进程组都会被系统终止。
  • 相关函数:
    #include <unistd.h>
    
    pid_t setsid(void);
        // 创建一个新的进程会话,然后返回其 SID
        // 创建的新会话中,由当前进程担任 Group Leader 和 Session Leader
        // 如果当前进程本来就是当前进程组的 Group Leader ,则不允许创建,避免与当前进程组的其它进程处于不同的会话中
    

# 守护进程

  • 前台进程
    • :绑定到当前终端的 stdin ,因此会阻塞当前终端。
    • 普通方式启动的进程默认会绑定到当前终端的 stdin、stdout、stderr 。
  • 后台进程
    • :没有绑定到终端的 stdin ,但可能绑定了 stdout、stderr 。
    • 前台进程、后台进程都是当前终端的子进程。如果用户关闭当前终端,系统就会给这些进程发送 SIGHUP 信号,终止它们。
  • 守护进程(daemon)
    • :一种特殊的后台进程。运行在一个独立的 Process Session 中,完全脱离用户的终端,不会收到 SIGHUP 信号。
    • 系统服务程序通常以守护进程的方式运行。

# 僵尸进程

  • 在类 Unix 系统中,进程退出的流程:

    1. 一个进程终止运行(包括主动退出、被杀死的情况)。
    2. 内核回收该进程占用的内存、文件等资源,并向其父进程发送 SIGCHLD 信号,通知它有一个子进程退出了。
    3. 父进程调用 wait() 或 waitpid() 获取该进程的退出状态。
    4. 内核在进程表中删除该进程,删除其 /proc/<PID>/ 目录,使该进程完全消失。
  • 进程在终止运行之后、完全消失之前,状态为 terminated ,称为僵尸进程(Zombie Process)。

    • 如果僵尸进程越来越多,可能占用内核的所有 PID ,导致不能创建新进程。
    • 僵尸进程不能被 kill 命令杀死,因为它已经终止运行了。
  • Windows 系统中,进程退出时会被立即回收、删除,因此不会产生僵尸进程。

  • init 进程会不断调用 wait() 获取其子进程的退出状态,避免产生僵尸进程。

    • 因此,孤儿进程没有危害,会被 init 进程管理,不会变成僵尸进程。但僵尸进程如果不回收,则会一直存在。
  • 避免产生僵尸进程的几种措施:

    • 子进程终止时通知父进程,让父进程立即回收它。
      • 比如向父进程发送 SIGCHLD 信号,不过一般的进程会忽略该信号。
    • 父进程不断轮询子进程是否终止。
    • 终止父进程,从而让子进程变为孤儿进程,被 init 进程管理。
      • 比如先让当前进程 fork 一个子进程,再让子进程 fork 一个孙进程,然后立即回收子进程。这样孙进程就变为了孤儿进程。
  • 例:

    1. 在 Python 解释器中执行 p = subprocess.Popen('sleep 10', shell=True) 创建子进程。
    2. 执行 ps 命令查看:
      29457 root      20   0  147.2m   8.8m   3.4m S   0.0  0.1   0:00.09          `- python3
      29860 root      20   0  105.5m   0.3m   0.3m S   0.0  0.0   0:00.00              `- sleep 10
      
    3. 当子进程执行完之后,就会变成僵尸进程:
      29457 root      20   0  147.2m   8.8m   3.4m S   0.0  0.1   0:00.09          `- python3
      29860 root      20   0    0.0m   0.0m   0.0m Z   0.0  0.0   0:00.00              `- [sleep] <defunct>
      
    4. 在 Python 解释器中执行 p.wait() ,僵尸进程就会消失。
      • 另外,创建新的子进程时,Python 会自动清理所有僵尸态的子进程。

# 进程属性

# 标识符

Linux 系统会给每个进程、线程分配一个标识符(ID),包括:

  • PID :进程的 ID ,在整个系统中唯一。
  • PPID :父进程的 ID 。
  • TID :线程的 ID ,在其线程组中唯一。
  • PGID :进程组(Process Group)的 ID ,等于其主进程的 ID 。
  • TGID :线程组(Thread Group)的 ID ,等于其主线程的 ID 。
  • SID :Process Session 的 ID ,等于其主进程的 PID 。

# 进程类型

  • s :该进程是 Session Leader 。
  • + :该进程属于前台进程。
  • < :high-priority (not nice to other users)。
  • N :low-priority (nice to other users)。
  • L :已锁定内存中的 page 。
  • l :是多线程的。

# 运行状态

  • R :Running
    • 进程处于 Running 状态时才会占用 CPU 。
  • S :Sleeping
    • 此时进程处于可中断的睡眠状态,被 CPU 挂起,等到某一时刻或满足某些条件时再继续运
    • 例如,HTTP 服务器通常一直处于 Sleeping 状态,收到 HTTP 请求时才有一瞬间切换到 Running 状态。
  • D :Disk Sleep
    • 此时进程处于不可中断的睡眠状态,不会响应异步信号,因此不能被 kill -9 杀死。
    • 例如,进程等待磁盘 IO 时,会进入短暂的 D 状态。
  • I :Idle ,即空闲状态。
  • Z :Zombie ,僵尸进程。
  • T :Stopped ,暂停状态。
  • t :Traced ,比如进程被断点调试时处于被跟踪状态。
  • X :进程正在终止,这是一个很短暂的状态。

# 进程间通信

Linux 系统上,进程间通信(Inter Process Communication ,IPC)的主要方式如下:

# 信号

  • 信号(signal)可能来源于硬件(比如键盘信号),也可能来源于软件(比如用 kill 命令)。信号产生后,会被内核发送给进程,相当于软件层的模拟中断。

  • Linux 定义了多种信号,常见的如下:

    编号 宏定义名 默认动作
    1 SIGHUP 终止进程
    2 SIGINT 终止进程
    3 SIGQUIT 终止进程
    9 SIGKILL 终止进程
    10 SIGUSR1 终止进程
    12 SIGUSR2 终止进程
    15 SIGTERM 终止进程
    17 SIGCHLD 表示子进程终止,默认无动作
    19 SIGSTOP 暂停进程
    • 在不同的平台上,信号的编号可能有差异,因此最好通过宏定义名来指定信号。
    • SIGINT 通常由键盘中断(Ctrl+C)引发。
    • 向某个进程发出一个普通的终止信号时,进程可能立即终止,也可能做完清理工作之后再终止(比如释放占用的资源),甚至不终止。
    • SIGKILL、SIGSTOP 两种信号不能被进程忽略或捕捉,因此一定会立即执行。
    • SIGUSR1、SIGUSR2 两种信号常用于被用户绑定自定义的信号处理函数。
      • SIGUSR1 的默认动作是终止进程,不过 Apache、Nginx 等很多程序收到 SIGUSR1 信号之后会进行复位操作,比如刷新缓存、重新加载配置文件、重新打开日志文件,接近于重启进程。
  • 相关 API :

    #include <signal.h>
    
    int kill(pid_t pid, int sig);   // 向进程发送信号,发送成功则返回 0
    
    • pid
      • 如果为 n > 0 ,则选中 PID 等于 n 的进程。
      • 如果为 0 ,则选中当前进程组的所有进程。
      • 如果为 -1 ,则选中当前进程有权限发送信号的所有进程。
      • 如果为 -n < -1 ,则选中 PGID 等于 n 的进程组中的所有进程。
      • 特别地,内核只允许将已注册 handler 的信号发送给 PID 为 1 的进程(通常是 init、systemd 等),会忽略 SIGKILL、SIGSTOP 等信号,避免杀死操作系统。不过此时调用 kill() 依然会返回 0 。
        • 因此,在主机上执行 kill -9 1 命令不会杀死 1 号进程。
    • sig
      • 可以填 int 值,也可以填 SIGTERM 等宏定义名。
      • 如果为 0 ,则不发送信号,但依然会检测目标进程是否存在、是否有权限发送信号。
  • 当进程收到一个信号时,有三种处理方式:

    • 执行信号的默认动作
    • 忽略信号
    • 捕捉信号:进程将自己的信号处理函数传给内核,与一个信号绑定。当该信号发生时,内核就会执行该函数,从而实现该进程自定义的动作。如下:
      #include <stdio.h>
      #include <signal.h>
      
      static void sig_handle(int sig_no)              // 定义信号处理函数
      {
          if(sig_no == SIGUSR1)
              printf("Received SIGUSR1\n");
          else
              printf("Received signal %d\n", sig_no);
      }
      
      int main(void){
          if(signal(SIGUSR1, sig_handle) == SIG_ERR)  // 绑定信号处理函数
              printf("Can not catch SIGUSR1\n");      // 如果不能绑定即不能捕捉,则报错
          return 0;
      }
      

# 信号量

  • :semophore ,一个非负整数,用于记录某个资源的可用数量。为 0 时表示资源不可用。

# 套接字

# 管道文件

  • 进程可以创建一个管道文件(pipe),和另一个进程同时连接到它,从中读写数据。
  • 采用半双工通信,当一个进程写数据时,另一个进程只能读数据。
  • 匿名管道(PIPE):保存在内存中,没有文件描述符,只能用于父子进程之间的通信。比如管道符 | 。
  • 命名管道(FIFO):保存为文件系统中的一个文件,常用于两个独立进程之间的通信。

# 消息队列

  • :message queue ,一个链表结构,允许多个进程从中读写数据。

# 共享内存

  • :shared memory ,一块内存空间,允许被多个进程同时访问。

# 相关 API

# PCB

  • Linux 内核会在内存中保存一个进程表(process table),记录当前存在的所有进程,包括其 PID、PCB 。

    • 用户可以通过 /proc/<PID>/ 目录获取进程的 PCB 信息。
  • 每个进程用一个 task_struct 结构体记录其信息,称为进程控制块(Process Control Block ,PCB)、进程描述符。如下:

    struct task_struct
    {
        volatile long state;              // 进程的运行状态
        void *stack;                      // 进程的内核栈
        atomic_t usage;                   // 进程描述符的使用计数
        unsigned int flags;               // 进程的状态标志
    
        int prio;                         // 进程的 CPU 调度优先级
        unsigned int policy;              // 进程的 CPU 调度策略
        cpumask_t cpus_allowed;           // 进程可以在 CPU 的哪些核上执行
    
        int exit_state;                   // 进程的退出码
        pid_t pid;                        // 进程的标识符
    
        struct task_struct *parent;       // 一个指针,指向父进程
        struct task_struct *group_leader; // 一个指针,指向当前进程组的主进程
        struct list_head children;        // 一个链表,其中每个元素表示一个子进程
    
        cputime_t utime, stime;           // 进程占用的用户态、内核态 CPU 时长
        struct timespec start_time;       // 进程的启动时刻
    
        ...
    }
    
  • 用户可以给进程设置 Nice 优先级,而内核运行进程时会转换成 Priority 优先级。

    • Nice
      • 取值范围为 -20~19 ,取值越小表示优先级越高。默认为 0 。
      • Nice 也表示友好度。如果一个进程增加其 Nice ,就是降低优先级,对其它进程更友好。
    • Priority
      • 取值范围为 -100~39 ,取值越小表示优先级越高。
      • 对于普通进程,其 Priority = Nice + 20 ,取值范围为 0~39 。
      • 对于 RT 类型的进程,其 Priority = -1 - rt_prior ,取值范围为 -100~-1 。
        • rt_prior 取值范围为 0~99 ,取值越大,优先级越高。
  • 进程的 CPU 调度策略分为多种:

    SCHED_OTHER   # 对于多个进程尽量平均分配时间,因此占用 CPU 时间较短的进程会被优先调度
    SCHED_BATCH   # 批处理
    SCHED_IDLE    # 运行低优先级的后台 job
    SCHED_FIFO    # 按先来后到的顺序执行进程,直到进程主动释放 CPU ,或被更高优先级的进程抢占 CPU
    SCHED_RR      # 与 SCHED_FIFO 类似,但是给每个进程分配时间片,如果耗尽,则轮到相同优先级的其它进程
    
    • Linux v2.6 开始,默认采用 CFS(Completely Fair Scheduler)作为 CPU 调度算法。
    • CPU 调度时,是以线程为单位。
    • SCHED_FIFO、SCHED_RR 采用实时(Real Time ,RT)调度类,对应的进程称为 RT 类型。

# 创建进程

  • 关于创建进程:

    #include <unistd.h>
    
    pid_t fork(void);
        // 拷贝当前进程,创建一个子进程
        // 如果创建成功,则在父进程中返回子进程的 PID ,在子进程中返回 0
        // 如果创建失败,则返回 -1
    
    • 调用 fork() 创建的子进程,与父进程几乎完全相同,比如:
      • 拷贝父进程的虚拟内存空间。
      • 拷贝父进程打开的文件描述符。
    • 调用 fork() 创建的子进程,是一个独立的新进程,与父进程存在少量差异,比如:
      • 拥有不同的 PID 。
      • 将资源使用率、CPU 使用时长重置为零,重新计算。
      • 将待处理的信号集清空。
  • 关于执行程序:

    #include <unistd.h>
    
    int execve(const char *pathname, char *const argv[], char *const envp[]);
        // 执行 pathname 对应的二进制文件,并传入参数 argv 、环境变量 envp
    
    • 调用 execve() 时,是执行另一个程序,替换当前程序。
      • 这会覆盖当前进程的数据段、堆栈。不过进程的 PID 不变,已经打开的文件描述符会保留。
    • 例如:在终端执行 ls -l 命令时,是先调用 fork() 创建子进程,而子进程再执行 execve("/usr/bin/ls", ["ls", "-l"], 0x7ffc0e3d0910 /* 29 vars */)

# 终止进程

  • 关于终止进程:

    #include <stdlib.h>
    
    void exit(int status);
        // 使当前进程退出,且退出码取值为 status
    
  • 关于等待进程退出:

    #include <sys/wait.h>
    
    pid_t wait(int *status);
      // 阻塞当前线程,直到一个子进程退出,然后返回其 PID
      // 如果没有子进程或执行失败,则返回 -1
    
    pid_t waitpid(pid_t pid, int *status, int options);
      // 阻塞当前线程,直到指定子进程的运行状态改变(默认是等待变为 terminated 状态)
    
    • pid
      • 如果为 n > 0 ,则等待 PID 等于 n 的子进程。
      • 如果为 0 ,则等待当前进程的任一子进程。
      • 如果为 -1 ,则等待任一子进程。
      • 如果为 -n < -1 ,则等待 PGID 等于 n 的进程组中的任一子进程。
    • 例:
      wait(NULL);               // 相当于 waitpid(-1, NULL, 0);
      while (wait(NULL) > 0);   // 阻塞当前线程,直到所有子进程都退出
      
    • 例:
      #include <stdio.h>
      #include <unistd.h>
      #include <sys/wait.h>
      
      int main(){
          pid_t pid;
          pid = fork();         // 此时拷贝了一个子进程,往下的代码是主进程、父进程同时各执行一份
          if (pid < 0)
              printf("Failed to fork");
          else if (pid == 0)
              printf("This is child process: [%d] . Its parent process is [%d] \n", getpid(), getppid());
          else{
              printf("This is parent process: [%d] . It just created a child process: [%d] \n", getpid(), pid);
              pid = wait(NULL); // 等待子进程终止
              printf("The child process [%d] has terminated.\n", getpid(), getppid(), pid);
          }
          return 0;
      }
      
      运行结果:
      This is parent process: [9961] . It just created a child process: [9962]
      This is child process: [9962] . Its parent process is [9961]
      The child process [9961] has terminated.