一、什么是进程

1、进程概念

在通常的计算机书籍或者课本中对进程概念的描述是这样的 – 进程就是被加载到内存中的程序，或者被运行起来的程序就叫做进程；这样说的原因如下：

首先，从 【Linux】计算机的软硬件体系结构 中我们知道，为了提高计算机的整体效率，在数据层面，CPU 不会直接和外设打交道，而只会和内存进行交互；同样，外设也只和内存交互；

其次，我们平时编写的 C/C++ 代码经过编译链接后形成的二进制可执行程序其实本质上就是存放在磁盘上的一个文件；所以如果我们要运行这个程序，就必须先将其加载到内存，因为CPU要从内存中读取程序中的代码和数据进行运算。

但是同时，在程序加载进内存后，操作系统要对程序进行管理，而从上一节的学习中我们知道，对程序的管理本质上是对程序数据的管理，且管理的方法是先描述，再组织；

所以操作系统会从这些程序中抽象出共有的属性来构建一个结构体，然后为每一个进程都创建一个结构体的对象，最后再将所有的结构体对象使用某一种高效的数据结构组织起来；至此，对某个进程的管理就转变成了对数据结构中某一个节点的管理。在操作系统中，这个用于描述和组织进程的东西被称为 进程控制块 – PCB。

2、进程描述 – PCB

进程控制块PCB (process control block)：操作系统中用于描述进程的工具，其中包含的是进程属性的集合；Linux操作系统下的PCB是 task_struct，它是Linux内核的一种数据结构，其内容可以分为如下几类：

• 标示符: 描述本进程的唯一标示符，用来区别其他进程；
• 状态: 任务状态，退出代码，退出信号等；
• 优先级: 相对于其他进程的优先级；
• 程序计数器: 程序中即将被执行的下一条指令的地址；
• 内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针；
• 上下文数据: 进程执行时处理器的寄存器中的数据；
• I/O状态信息: 包括显示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表；
• 记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等；
• 其他信息

抽象出来可以用如下结构体来表示 (假设task_struct使用链表进行组织)：

struct task_struct {     
  //进程的所有属性
    ... ...
  //进程对应的代码和数据的地址
    ... ...
  //下一个进程的地址
	struct task_struct* next;
};

Linux中task_struct的部分源码如下：

注：关于 task_struct 的详细介绍，即其中包含了那些具体的进程属性，可以参考下面这篇文章：Linux中进程控制块PCB-------task_struct结构体结构 。

当了解了task_struct之后，我们就应该从操作系统内核的观点来看待进程了：进程 = 内核数据结构 (task_struct) + 进程对应的磁盘代码。

---

二、进程的一些基本操作

1、查看进程

我们可以通过以下两种方式来查看进程：

(1) ps axj 指令配合 grep 和 管道查看指定进程：

//test.c
#include <stdio.h>
#include <unistd.h>

int main()
{
    while(1)
    {
        printf("hello process!\n");
        sleep(1);
    }
    return 0;
}

(2) 在 “/proc” 系统文件夹中查看所有进程：

2、结束进程

对于我们自己编写的普通进程来说，我们可以使用 [Ctrl + c] 来结束；也可以使用 kill 命名，指定 -9 选项来结束：

2、通过系统调用获取进程标示符

我们可以通过使用操作系统给我们提供的系统调用接口 getpid() 与 getppid() 来获取进程id和父进程id (进程ID是一个进程的唯一标识)：

注：关于函数的返回值 pid_t，大家把它当作 int 看待即可，打印的时候也使用 %d；

//test.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main()
{
    while(1)
    {
        printf("我是一个进程，我的ID是：%d，我的父进程ID是：%d\n", getpid(), getppid());
        sleep(1);
    }
    return 0;
}

可以看到，我们通过 getpid() 和 getppid() 函数得到的值的确是我们进程对应的id；同时，我们发现 test 进程的父进程是 bash，即 shell 外壳，这也侧面证实了我们在 【Linux】权限管理 中提到的结论 – shell 为了防止自身崩溃，并不会自己去执行指令，而是会派生子进程去执行。

另外，同一个程序重新被运行时它的进程id可能与之前不一样，因为它的代码和数据需要重新从磁盘中加载；但是它的父进程id一定是一样的，因为它们都是通过 bash 来执行；

3、通过系统调用创建子进程

我们可以通过系统调用接口 fork 来创建子进程：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main()
{
   pid_t id = fork();
   if(id == 0)
   {
       while(1)
       {
        printf("子进程，pid:%d, ppid:%d, id:%d\n", getpid(), getppid(), id);
        sleep(1);
       }
   }
   else if(id > 0)
   {
        while(1)
        {
            printf("父进程，pid:%d, ppid:%d, id:%d\n", getpid(), getppid(), id);
            sleep(1);
        }
   }
   else 
   {
       printf("子进程创建失败!\n");
   }
    return 0;
}

可以看到，结果和我们预期一样，子进程的 ppid 是 父进程的 pid，父进程的 ppid 是 bash，同时，对于父进程，fork 函数返回子进程的 pid，对于子进程，fork 返回 0。

---

三、进程状态

1、普适的操作系统层面

什么是进程状态：我们知道，一个程序被加载到内存变成进程之后，操作系统要对该进程进行管理，即为其创建对应的PCB对象；而进程状态，本质上就是PCB内部的一个整形变量，不同的整形值就对应不同的进程状态。

在普适的操作系统层面，即站在操作系统学科的角度来说，进程状态可能有如下几种：运行、挂起、阻塞、新建、就绪、等待、挂机、死亡；其中最重要也是最难理解的几种状态分别是：运行、阻塞、挂起。

运行状态

操作系统为了合理分配CPU以及各种硬件资源，也为了更好的调度各个进程，会为CPU创建一个进程队列，为每一个硬件都创建一个等待队列；而让某一个进程处于运行状态本质上就是将该进程对应的PCB放入CPU的运行队列中，然后再将PCB中维护进程状态的变量修改为相应的值，比如0；

因为进程PCB里面有进程的各种属性，以及进程对应的代码和数据的地址，所以CPU从运行队列中取出PCB后，可以根据该PCB来得到进程的各种数据和指令，然后执行相应运算；

所以进程处于运行状态并不一定意味着该进程此刻正在被运行，只要该进程处于CPU的运行队列中即可。(注：CPU是纳秒级的芯片，运算速度非常快，所以只要进程处于CPU的运行队列中，我们就可以认为该进程正在被运行)

阻塞状态

和CPU一样，我们计算机中的各种硬件也是十分有限的，但是需要使用这些硬件资源的进程却有很多，比如很多进程都需要向磁盘中写入数据，又或者要通过网卡发送数据；但是一个磁盘或者一个网卡在同一个时刻只能为一个进程提供服务，那么如果此时有其他运行中的进程需要使用该硬件资源，操作系统就会将该进程的PCB放入硬件的等待队列中，等待硬件来为我提供服务。

上面这种由于访问某种硬件需要进行等待的状态就被称为阻塞状态，阻塞状态本质上就是将进程的PCB从CPU的运行队列中剥离出来，放入硬件的等待队列中，然后将PCB中维护进程状态的变量修改为相应的值，比如1；待该进程获得对应的对应的硬件资源以后，再将该进程放入CPU的运行队列中。

注：并不是只有等待硬件资源进程才会处于阻塞状态，一个进程等待另一个进程就绪、一个进程等待某种软件资源就绪等都会处于阻塞状态。

挂起状态

上面我们学习了阻塞状态，处于阻塞状态的进程由于需要等待某种资源，所以它对应的代码和数据在短期内并不会被执行，此时它们仍存在在内存中就相当于浪费了内存资源；而如果当前操作系统处于高IO的情况下，内存空间不足，操作系统就会选择将这些处于阻塞状态的进程对应的代码和数据拷贝一份存放到磁盘中，然后释放内存中那一份，从而节省出内存空间；

上面这种由于内存空间不足，操作系统将在等待资源的进程对应的代码数据放到磁盘中以节省内存空间的状态就被称为挂起状态；挂起状态不会移动进程的PCB，只会移动进程对应的代码和数据。

注：挂起进程并不是释放进程，因为该进程对应的PCB仍然处于某硬件的等待队列中，当该进程获得对应的资源以后，操作系统仍然可以将该进程对应的代码和数据从磁盘加载到内存中来继续运行，其本质是对内存数据的唤入唤出；同时阻塞不一定挂起，挂起也不一定阻塞，也可能是新建挂起、就绪挂起，甚至是运行挂起。

总结：进程状态改变的本质是进程对应的 PCB (task_struct 对象) 处于不同设备的运行队列/等待队列中。

---

2、具体Linux操作系统层面

上面我们谈到的都是理论上的操作系统中进程的状态，下面我们来学习具体Linux操作系统中进程的状态。

Linux内核源代码中对进程状态的定义如下：

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/
static const char * const task_state_array[] = {
"R (running)", /* 0 */
"S (sleeping)", /* 1 */
"D (disk sleep)", /* 2 */
"T (stopped)", /* 4 */
"t (tracing stop)", /* 8 */
"X (dead)", /* 16 */
"Z (zombie)", /* 32 */
};

可以看到，Linux中进程一共有七种状态，分别是运行、睡眠、深度睡眠 (磁盘休眠)、暂停、追踪暂停、死亡、僵尸；

运行状态 ( R )

运行状态即进程的PCB位于CPU的运行队列中：

睡眠状态 (S)

Linux下的睡眠状态其实就是我们上面所说的阻塞状态，进程需要等待某种资源：

注：我们使用 ps axj 指令查看进程状态只能查看进程某一时刻的状态，而外设的速度是要远远低于CPU的，所以我们可以发现，虽然 process 也在执行加法运算，但是我们每次查询时进程基本都处于阻塞状态，因为进程99%的时间都在等待硬件资源就绪，只有1%的时间在进行加法运算以及执行打印代码。

深度睡眠状态 (D)

上面我们提到，当内存空间不足的时候，操作系统会将一部分进程挂起来节省资源；但是如果内存空间严重不足，挂起已经解决不了问题的时候，操作系统就会主动杀掉某些进程；

那么这里就出现了一个问题，万一操作系统把某些非常重要的进程杀掉了怎么办？比如，当前有一个进程需要向磁盘写入一批数据，这批数据是10万名用户一年的转账记录，非常重要；该进程访问磁盘，让磁盘帮它写入数据，在磁盘写数据的时间段内，该进程是属于阻塞状态的，因为它要等待磁盘返回给它一个结果，即是否写入成功；而一旦该进程被操作系统杀掉，且恰好磁盘写入失败了，磁盘将写入结果反馈给该进程发现无人应答，磁盘就只能将该部分数据丢弃然后为其他进程提供服务；此时，这部分十分重要的用户数据就丢了。

为了防止这种情况的发生，Linux设计出了深度睡眠 (D) 状态，处于深度睡眠状态的进程既不能被用户杀掉，也不能被操作系统杀掉，只能通过断电，或者等待进程自己醒来。

注：深度睡眠一般只会在高IO的情况发生下，且如果操作系统中存在多个深度睡眠状态的程序，那么说明该操作系统也即将崩溃了。

暂停状态 (T)

暂停状态其实也属于阻塞状态的一种，我们可以使用 kill 命名，指定 -19 选项来让一个进程从运行状态变为暂停状态：

当然，我们也可以使用 kill -18 让一个处于暂停状态的进程恢复运行：

细心的同学可能注意到了一个细节：我们将 process 暂停或者 continue 之后，进程状态前面的 + 号消失了；其实，进程状态后面的 + 号代表着一个进程是前台进程，没有 + 号就代表是后台进程；对于前台进程，我们可以使用 Ctrl + c 将其终止，也可以用 kill 命令杀死它；但是对于后台进程来说，我们只能通过 kill 命令来杀死它。

追踪暂停状态 (t)

追踪暂停状态是一种特殊的暂停状态，进程处于此状态表示该进程正在被追踪，比如 gdb 调试进程：

死亡状态 (X)

死亡状态代表着一个进程结束运行，该进程对应的PCB以及代码和数据全部被操作系统回收。

僵尸状态 (Z)

我们创建一个进程的目的是为了让其帮我们完成某种任务，而既然是完成任务，进程在结束前就应该返回任务执行的结果，供父进程或者操作系统读取。

所以，一个进程在退出的时候，不能立即释放全部资源 – 对于进程的代码和数据，操作系统可以释放，因为该进程已经不会再被执行了，但是该进程的PCB应该保留，因为PCB中存放着该进程的各种状态代码，特别是退出状态代码。

僵尸状态就是进程在退出时等待父进程或者操作系统来读取退出状态代码，然后释放PCB的一种状态。

总结：可以看到，具体的Linux操作系统下的进程状态和普适的操作系统学科上进程的状态是不同的，比如Linux操作系统没有阻塞和挂起状态，阻塞状态通过睡眠、深度睡眠、暂停、追踪暂停等状态表现出来，而进程处于这些状态时是否会被调整为挂起状态，用户是不可得知的，因为操作系统没必要将挂起状态暴露给用户，用户也不关心一个进程是否会处于挂起状态。

---

四、两种特殊的进程

1、僵尸进程

什么是僵尸进程

上面我们提到一个进程的资源在被全部释放之前，需要由父进程或者操作系统来读取退出状态代码，而如果父进程不读取子进程的退出状态代码，该进程的PCB就一直得不到释放，此时该进程就会变成僵尸进程。

我们下面举例说明：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>

int main()
{
    int id = fork();
    if(id > 0)
    {
        while(1)
        {
            printf("我是父进程，pid: %d, ppid: %d\n", getpid(), getppid());
            sleep(1);
        }
    }
    else if(id == 0)
    {
        while(1)
        {
            printf("我是子进程，pid: %d, ppid: %d\n", getpid(), getppid());
            sleep(1);
        }
    }
    else 
    {
        perror("fork fail");
        exit(-1);
    }
    return 0;
}

可以看到，当我们 kill 掉子进程1125之后，由于父进程中没有对子进程的退出状态代码进行读取，所以子进程变成了 Z 状态，并且子进程后面还提示了 defunct (失效的，不再使用的)，此时，如果父进程一直不对不对子进程进行读取，那么子进程就会变成僵尸进程。

僵尸进程有如下危害

如果父进程或者操作系统一直不对子进程的退出状态进行读取，那么子进程的退出状态就将一直被维持下去；维护退出状态本身就是要用数据维护，也属于进程基本信息，所以如果进程一直处于退出状态，进程对应的 PCB (task_struct) 就将一直存在，不会被释放；会造成内存资源的浪费。

2、孤儿进程

孤儿进程是指父进程提前退出后，子进程被操作系统领养的一种情况，被操作系统领养的进程就被称为孤儿进程；

这里还有两个细节：第一，父进程退出后并没有变成Z状态，因为父进程的父进程是bash，bash会读取父进程的退出状态；第二，子进程被领养后变成了后台进程。

---

五、进程优先级

什么是优先级

优先级和权限不同，权限决定的是一件事情能不能做；优先级是在权限允许的前提下，该事情先做还是后做；

为什么要有优先级

资源是有限的，内存中有很多进程都要占用资源，但是资源是有限的，所以我们需要指定优先级来合理的分配资源；

Linux中优先级的特点

Linux 中优先级的表示与维护通过两个变量 PRI (priority) 和 NI (nice) 来完成，每个进程默认的 PRI 都是 80，NI 都是 0；我们可以通过修改 NI 的值来调整进程的优先级，NI 的改动范围为 [-20, 19]；PRI 与 NI 的和越小，进程的优先级就越高；

Linux 中我们通过 ps -l 来查看进程的优先级：

我们也可以通过如下步骤来修改进程优先级 (将进程优先级调高可能需要 sudo 权限)：

输入top --> 输入r --> 输入进程id --> 输入NI值

最后，虽然我们可以通过修改 NI 值来调整进程优先级，但是我们一般都不会这样做，因为效果不大。

六、进程的其他概念

进程还有一些其他概念：

• 竞争性：系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的；(进程为了高效完成任务，更合理竞争相关资源，便具有了优先级)
• 独立性：多进程运行，需要独享各种资源，多进程运行期间互不干扰；(每个进程的PCB以及代码数据都是独立的，一个进程的死亡不会影响其他进程，包括父子进程，子进程崩溃并不会影响父进程)
• 并行：多个进程在多个CPU下分别、同时进行运行，这称之为并行；
• 并发：多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发。(我们用的电脑一般都是并发，只有一个CPU)

七、进程切换

我们的笔记本只有一个CPU，代表着同一时刻只能有一个进程正在被运行，但是我们平时在使用电脑的时候，同一时间通常会运行着很多程序，并且这些程序都能被正常运行，这其实是进程切换的效果；

进程切换：CPU同一时刻只能运行一个进程，但是CPU的运算速度非常快，所以位于CPU运行队列中的每一个进程都只运行一个时间片，每个进程运行完一个时间片后被都被放到运行队列尾部，等待下次运行；这样使得在一个时间段中多个进程都能被运行。

上下文保护与上下文恢复

CPU在进行进程切换时要进行上下文保护与上下文恢复：

我们的进程在运行时会产生非常多的临时数据，同时CPU中存在一套寄存器硬件，当进程运行时，进程的PCB会被放入CPU内的寄存器中，此时CPU就可以通过进程PCB得到进程代码数据的地址；CPU在运行进程时所产生的大量的临时数据也都会被保存在寄存器中；

那么，我们在进行进程切换时需要进行进程的上下文保护与上下文恢复，即进程停止运行时将寄存器里面的数据保存起来，进程重新运行时将保存的数据再放入到寄存器中；以便我们能够接着上次运行的地方接着运行。

注：CPU寄存器硬件被所有进程共享，但是当CPU在具体运行某一进程时，CPU寄存器中的数据只属于该进程；同时，我们进行上下文保护时保存的是寄存器中的数据，而不是寄存器硬件。

---