1、进程的基本概念

在给进程下定义之前，我们先了解一下进程：

我们在编写完代码并运行起来时，在我们的磁盘中会形成一个可执行文件，当我们双击这个可执行文件时（程序时），这个程序会加载到内存中，而这个时候我们不能把它叫做程序了，应该叫做进程。

所以说，只要把程序（运行起来）加载到内存中，就称之为进程。

进程的概念：程序的一个执行实例，正在执行的程序等

2、描述进程-PCB

PCB：进程控制块（结构体）（process control block的缩写）

当一个程序加载到内存中，操作系统要为刚刚加载到内存的程序创建一个结构体（PCB）,进程信息被放在这个结构体中（PCB）,可以理解为PCB是进程的属性的集合。

在Linux操作系统下的PCB是：task_struct

task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息

在进程执行时，任意时间内，进程对应的PCB都要以下内容：

标示符：描述本进程的唯一标示符，用来区别其他进程

状态：任务状态

优先级：相对于其他进程的优先级

程序计数器：程序中即将被执行的下一条指令的地址

内存指针：包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块指针

上下文数据：进程执行时处理器的寄存器中的数据

I/O状态信息：包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表

记账信息：可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等

其他信息：…

优先级的理解：

由于CPU只要一个，进程可以有多个，所以CPU的资源有限，操作系统在调度进程到CPU时会根据进程的优先级来判断。

程序计数器的理解：

CPU跑一个进程时，要执行它的代码，而代码是自上往下执行的（if、else、循环等除外），CPU先要取指令，然后分析指令，再然后执行指令。取完一个指令后，CPU中的寄存器（EIP指令寄存器）会保存当前指令的下一条指令的地址，方便下次取下一个指令。所谓的函数跳转、分支判断、循环等，都是修改EIP完成的。

上下文数据的理解：

CPU在跑一个进程时，没有跑完就开始切换其他进程，为了下次继续跑完这个进程，会保留这个进程的上下文数据，当这个进程回来时，会把上下文数据移动到CPU内部继续执行。

所以为什么会存在进程控制块PCB呢？

操作系统要进行软硬件的资源管理，要管理资源就要先对资源描述再组织，要描述就必须有PCB结构体。Linux中可以在内核里找到task_struct，所有运行在系统里的进程都以task_struct链表的形式存在内核里。

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

在Linux中查看进程信息，使用命令ps aux

例如，我写了一份test.c的程序，./test运行之后，可以使用命令

ps aux | grep test | grep -V grep

说明一下，grep是查找命令，后面跟上-V是过滤信息。

下面开始说明，程序中如何获取进程标识符。

进程id（PID）

父进程id（PPID）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{printf("pid: %d\n", getpid());printf("ppid: %d\n", getppid());return 0;
}

其中getpid()是找进程的标示符，getppid()找父进程的标示符

4、通过系统调用创建进程-fork初识

fork有两个返回值

父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{int ret = fork();printf("hello proc : %d!, ret: %d\n", getpid(), ret);sleep(1);return 0;
}

fork之后通常要用if进行分流，fork函数使用代码如下所示。

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{int ret = fork();if (ret < 0) {perror("fork");return 1;}else if (ret == 0) { //childprintf("I am child : %d!, ret: %d\n", getpid(), ret);}else { //fatherprintf("I am father : %d!, ret: %d\n", getpid(), ret);}sleep(1);return 0;
}

这段代码有两个进程，并且它们的关系是父子关系。

什么是fork函数：

在调用fork函数之前，只有一个进程(父进程)，当这个进程调用fork函数之后，fork函数会复制一个进程(子进程)，区别是PID不同，它们的关系是父子关系。

fork函数会返回两次值：

给父进程返回子进程的pid。

给子进程返回0。

失败时，在父进程中返回-1，不创建子进程，并且errno被适当地设置。

5、进程状态

为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务）。

下面的状态在kernel源代码里定义：

/*
* 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 */
};

R运行状态（running） : 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。

S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））。

D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。

T停止状态（stopped）：可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。

X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

R 可执行状态

通过命令ps aux

进程中的R状态不代表正在运行，代表的可被调度，此运行相当于上面的就绪态。

操作系统会把进程中R状态的进程全放在调度队列中，方便调度

S 睡眠状态

用代码创建一个睡眠状态的进程：

创建了一个可执行态进程

#include<stdio.h>
#include<unistd.h>
int main() 
{while(1);return 0;
}

创建休眠态进程

#include<stdio.h>
#include<unistd.h>
int main() 
{while(1)sleep(10);return 0;
}

S状态是浅度睡眠，随时可以被唤醒，也可以被杀掉。

D 磁盘休眠状态

可以表示为深度睡眠，该进程不会被杀掉，即使你是操作系统，除非我自动唤醒，才可以恢复。

T 暂停状态

向进程发送SIGSTOP信号，该进程会响应该信号进入暂停状态，

向该进程发送SIGCONT信号，该进程会从暂停状态恢复到可执行状态。

Z 僵尸状态

僵尸状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用,后面讲）没有读取到子进程退出的返回代码时就会产生僵尸进程

僵尸进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。

所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

举个例子：

一个人突然死亡，普通人不会对现场进行清理，而是报警等警察和法医对该人进行信息的采集，之后才清理现场。

其中，某人充当的角色是进程、警察和法医充当的角色的父进程或者操作系统。

#include <stdio.h>
#include <stdlib.h>
int main()
{pid_t id = fork();if (id < 0) {perror("fork");return 1;}else if (id > 0) { //parentprintf("parent[%d] is sleeping...\n", getpid());sleep(30);}else {printf("child[%d] is begin Z...\n", getpid());sleep(5);exit(EXIT_SUCCESS);}return 0;
}

编译并在另一个终端下启动监控

开始测试

看到结果

僵尸进程危害

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！

维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说， Z状态一直不退出， PCB一直都要维护？是的！

那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间

孤儿进程

父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？

父进程先退出，子进程就称之为“孤儿进程”

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{pid_t id = fork();if (id < 0) {perror("fork");return 1;}else if (id == 0) {//childprintf("I am child, pid : %d\n", getpid());sleep(10);}else {//parentprintf("I am parent, pid: %d\n", getpid());sleep(3);exit(0);}return 0;
}