一、进程的创建

阻塞状态：正在运行的进程由于某些原因调用阻塞原语把自己阻塞(如果不把自己阻塞的话会一直占用处理机）,等待相应的事件出现后才被唤醒，事件完成回到就绪状态。
通常这种处于阻塞状态的进程也排成一个队列。有的系统则根据阻塞原因的不同而处于阻塞状态进程排成多个队列。挂起状态是被迫被外界挂起，阻塞是正常流程中的一部分，是自愿阻塞。

系统中同时运行着很多进程,这些进程都是从一个进程开始一个一个复制出来的。进程通过fork系列的系统调用（fork、clone、vfork）来创建，内核（或内核模块）也可以通过kernel_thread函数创建内核进程。这些创建子进程的函数本质上都完成了相同的功能——将调用进程复制一份，得到子进程。（可以通过选项参数来决定各种资源是共享、还是私有）fork的作用是根据一个现有的进程复制出一个新进程,原来的进程称为父进程(Parent Process),新进程称为子进程(ChildProcess)。一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。

#include <unistd.h>
pid_t fork(void);

子进程复制父进程的0到3g空间和父进程内核中的PCB,但id号不同。fork调用一次返回两次:父进程中返回子进程ID,子进程中返回0。读时共享,写时复制。在Shell下输入命令可以运行一个程序是因为Shell进程在读取用户输入的命令之后会调用fork复制出一个新的Shell进程,然后新的Shell进程调用exec执行新的程序。父进程读取命令，子进程执行命令。父进程在调用fork创建子进程时会把自己的环境变量表也复制给子进程。

fork(写时复制):父进程调用fork()后
在虚拟地址空间子进程会复制父进程的代码段数据段 ?内核中的pcb文件描述度表也会复制但是其中的进程id不同。在物理存储空间子进程和父进程会先共享父进程的物理空间等到父子进程中出现对物理空间的修改时,再为子进程相应的段分配物理空间。
比如子进程执行exec就是对物理空间进行修改这个时候再去为子进程创建物理空间。fork以后严格意义上说父子进程调度顺序是不确定的但是一般是先执行子进程因为假设父进程对物理空间做了变动，然后按照上面所说要为子进程分配物理空间然后子进程执行exec ?还是要覆盖掉刚刚赋值的内容。vfork在写时复制的基础上进行改进，子进程连虚拟地址空间也不复制了也共享父进程的。

fork出错可能有两种原因：
????1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。
????2）系统内存不足，这时errno的值被设置为ENOMEM。
????创建新进程成功后，系统中出现两个基本完全相同的进程，这两个进程执行没有固定的先后顺序，哪个进程先执行要看系统的进程调度策略。

fork()与vfock()都是创建一个进程，有以下区别：?
1.??fork()：子进程拷贝父进程的数据段，代码段，vfork ()：子进程与父进程共享数据段?
2.??fork()父子进程的执行次序不确定?
????vfork 保证子进程先运行，在调用exec 或exit 之前与父进程数据是共享的,在它调用exec或exit 之后父进程才可能被调度运行。?如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁。?
子进程拷贝父进程的代码段的例子：?

1.?#include<sys/types.h>
2.?#include<unistd.h>
3.?#include<stdio.h>
4.??
5.?int?main()
6.?{
7.?????pid_t?pid;
8.?????pid = fork();
9.?????if(pid<0)
10.?????????printf("error in fork!\n");
11.?????else?if(pid == 0)
12.?????????printf("I am the child process,ID is %d\n",getpid());
13.?????else?
14.?????????printf("I am the parent process,ID is %d\n",getpid());
15.?????return?0;
16.??
17.?}
1.?[root@localhost fork]# gcc -o fork fork.c
2.?[root@localhost fork]# ./fork
1.?I am the child process,ID is 4711
2.?I am the parent process,ID is 4710

fork()函数用于从已存在的进程中创建一个新的进程，返回值有两个，子进程返回0，父进程返回子进程的进程号，进程号都是非零的正整数，所以父进程返回的值一定大于零。在pid=fork();之后，父进程和新创建的子进程都在运行，所以如果pid==0，那么肯定是子进程，若pid ！=0(事实上大于0），那么是父进程在运行。而fork()函数子进程是拷贝父进程的代码段的，所以子进程中同样有
if(pid<0)?
?????????printf("error in fork!");?
?????else if(pid==0)?
?????????printf("I am the child process,ID is %d\n",getpid());?
?????else?
?????????printf("I am the parent process,ID is %d\n",getpid());?
这么一段代码，所以上面这段代码会被父进程和子进程各执行一次，最终由于子进程的pid==0,
而打印出第一句话，父进程的pid>0，而打印出第二句话。于是得到了上面的运行结果。?
看一个拷贝数据段的例子：?

1.?#include<sys/types.h>
2.?#include<unistd.h>
3.?#include<stdio.h>
4.??
5.?int?main()
6.?{
7.?????pid_t?pid;
8.?????int?cnt = 0;
9.?????pid = fork();
10.?????if(pid<0)
11.?????????printf("error in fork!\n");
12.?????else?if(pid == 0)
13.?????{
14.?????????cnt++;
15.?????????printf("cnt=%d\n",cnt);
16.?????????printf("I am the child process,ID is %d\n",getpid());
17.?????}
18.?????else
19.?????{
20.?????????cnt++;
21.?????????printf("cnt=%d\n",cnt);
22.?????????printf("I am the parent process,ID is %d\n",getpid());
23.?????}
24.?????return?0;
25.?}
1.?[root@localhost fork]# ./fork2
2.?cnt=1
3.?I am the child process,ID is 5077
4.?cnt=1
5.?I am the parent process,ID is 5076

?为什么不是2 ？因为fork?()函数子进程拷贝父进程的数据段代码段，所以?
cnt++;?
????printf("cnt= %d\n",cnt);
????return 0?
将被父子进程各执行一次，但是子进程执行时使自己的数据段里面的（这个数据段是从父进程那copy 过来的一模一样）count+1，同样父进程执行时使自己的数据段里面的count+1，?他们互不影响，便出现了如上的结果。

如果将上面程序中的fork （）改成vfork（）:
1.?[root@localhost fork]# gcc -o fork3 fork3.c
2.?[root@localhost fork]# ./fork3
3.?cnt=1
4.?I am the child process,ID is 4711
5.?cnt=1
6.?I am the parent process,ID is 4710
7.?段错误
?
vfock()是共享数据段的，?vfork 和fork 之间的另一个区别是：vfork 保证子进程先运行，在调用exec 或exit 之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁。?上面程序中的fork ()改成vfork()后，vfork()创建子进程并没有调用exec或exit，所以最终将导致死锁。?怎么改呢：?

1.?#include<sys/types.h>
2.?#include<unistd.h>
3.?#include<stdio.h>
4.??
5.?int?main()
6.?{
7.?????pid_t?pid;
8.?????int?cnt = 0;
9.?????pid = vfork();
10.?????if(pid<0)
11.?????????printf("error in fork!\n");
12.?????else?if(pid == 0)
13.?????{
14.?????????cnt++;
15.?????????printf("cnt=%d\n",cnt);
16.?????????printf("I am the child process,ID is %d\n",getpid());
17.???????? _exit(0);
18.?????}
19.?????else
20.?????{
21.?????????cnt++;
22.?????????printf("cnt=%d\n",cnt);
23.?????????printf("I am the parent process,ID is %d\n",getpid());
24.?????}
25.?????return?0;
26.??
27.?}
1.?[root@localhost fork]# gcc -o fork3 fork3.c
2.?[root@localhost fork]# ./fork3
3.?cnt=1
4.?I am the child process,ID is 4711
5.?cnt=2
6.?I am the parent process,ID is 4710

如果没有_exit（0）的话，子进程没有调用exec 或exit，所以父进程是不可能执行的，在子进程调用exec 或exit 之后父进程才可能被调度运行。?所以加上_exit(0);使得子进程退出，父进程执行，这样else 后的语句就会被父进程执行，?又因在子进程调用exec 或exit之前与父进程数据是共享的,所以子进程退出后把父进程的数?据段count改成1 了，子进程退出后，父进程又执行，最终就将count变成了2。?
为什么会有vfork，因为以前的fork 创建一个子进程时，将会创建一个新的地址空间，并且拷贝父进程的资源，而往往在子进程中会执行exec 调用，这样前面的拷贝工作就白费力气了。这种情况下就想出了vfork，它产生的子进程刚开始暂时与父进程共享地址空间（其实就是线程的概念了）。因为这时候子进程在父进程的地址空间中运行，所以子进程不能进行写操作，并且在儿子霸占着老子的房子时候，要委屈老子在外面歇着（阻塞）。一旦儿子执行了exec 或者exit 后，相于儿子买了自己的房子，这时候就相于分家了。

写时复制是有一块内存，由多个进程共享，属性是只读的，当有一个进程对这块内存进行写的时候，系统会先申请一块新的内存给他写。比如进程fork的时候，父子进程对应的物理地址都一样，这时候会在页表项中记录该物理地址是只读的，有一个进程写的时候，就会触发写保护异常。执行写时复制。

二、进程状态

1.运行态

运行态的进程可以分为3种情况：内核运行态、用户运行态、就绪态。只有在该状态的进程才可能在CPU上运行。而同一时刻可能有多个进程处于可执行状态，这些进程的task_struct结构（进程控制块）被放入对应CPU的可执行队列中（一个进程最多只能出现在一个CPU的可执行队列中）。进程调度器的任务就是从各个CPU的可执行队列中分别选择一个进程在该CPU上运行。

正在CPU上执行的进程定义为RUNNING状态、可执行但是尚未被调度执行的进程定义为READY状态，这两种状态在linux下统一为 TASK_RUNNING状态。Linux 中把所有处于运行、就绪状态的进程链接成一个双向链表,称为可运行队列(run_queue)。使用任务结构体中的两个指针:
Struct task_struct *next_run;/*指向后一个任务结构体的指针*/
Struct task_struct *prev_run;/*指向前一个任务结构体的指针*/
该链表的首结点为 init_task。系统设置全局变量 nr_running 记录处于运行、就绪态的进程数。

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

2.睡眠与暂停状态

(TASK_INTERRUPTIBLE)可中断的睡眠状态

当进程调用一个阻塞的系统函数时,该进程被置于睡眠(Sleep)状态,这时内核调度其它进程运行,直到该进程等待的事件发生了(比如网络上接收到数据包,或者调用sleep指定的睡眠时间到了)它才继续运行。处于这个状态的进程因为等待某事件的发生（比如等待socket连接、信号量）而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时（由外部中断触发、或由其他进程触发），对应的等待队列中的一个或多个进程将被唤醒。

一般情况下，进程列表中的绝大多数进程都处于TASK_INTERRUPTIBLE状态（除非机器的负载很高）。毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。

(TASK_UNINTERRUPTIBLE)不可中断的睡眠状态

不可中断，指的不是CPU不响应外部硬件的中断，而是指进程不响应异步信号。绝大多数情况下，进程处在睡眠状态时，总是应该能够响应异步信号的。否则发现，kill -9竟然杀不死一个正在睡眠的进程了.
TASK_UNINTERRUPTIBLE状态存在的意义在于，内核的某些处理流程是不能被打断的。如果响应异步信号，程序的执行流程中就会被插入一段用于处理异步信号的流程（这个插入的流程可能只存在于内核态，也可能延伸到用户态），于是原有的流程就被中断了。
? ? ? ?在进程对某些硬件进行操作时（比如进程调用read系统调用对某个设备文件进行读操作，而read系统调用最终执行到对应设备驱动的代码，并与对应的物理设备进行交互），可能需要使用TASK_UNINTERRUPTIBLE状态对进程进行保护，以避免进程与设备交互的过程被打断，造成设备陷入不可控的状态。这种情况下的TASK_UNINTERRUPTIBLE状态总是非常短暂的，通过ps命令基本上不可能捕捉到。
? ? ?linux系统中也存在容易捕捉的TASK_UNINTERRUPTIBLE状态。执行vfork系统调用后，父进程将进入TASK_UNINTERRUPTIBLE状态，直到子进程调用exit或exec。通过下面的代码就能得到处于TASK_UNINTERRUPTIBLE状态的进程：#include ? void main() { ?if (!vfork()) sleep(100); ?}?

(TASK_STOPPED or TASK_TRACED)暂停状态或跟踪状态
?? ? ? ?向进程发送一个SIGSTOP信号，它就会因响应该信号而进入TASK_STOPPED状态（除非该进程本身处于TASK_UNINTERRUPTIBLE状态而不响应信号）。（SIGSTOP与SIGKILL信号一样，是强制的，不允许用户进程通过signal系列的系统调用重新设置对应的信号处理函数）向进程发送一个SIGCONT信号，可以让其从TASK_STOPPED状态恢复到TASK_RUNNING状态。

当进程正在被跟踪时，它处于TASK_TRACED这个特殊的状态。“正在被跟踪”指的是进程暂停下来，等待跟踪它的进程对它进行操作。比如在gdb中对被跟踪的进程下一个断点，进程在断点处停下来的时候就处于TASK_TRACED状态。而在其他时候，被跟踪的进程还是处于前面提到的那些状态。

对于进程本身来说，TASK_STOPPED和TASK_TRACED状态很类似，都是表示进程暂停下来。而TASK_TRACED状态相当于在TASK_STOPPED之上多了一层保护，处于TASK_TRACED状态的进程不能响应SIGCONT信号而被唤醒。只能等到调试进程通过ptrace系统调用执行PTRACE_CONT、PTRACE_DETACH等操作（通过ptrace系统调用的参数指定操作），或调试进程退出，被调试的进程才能恢复TASK_RUNNING状态。

3.退出状态

一个进程在执行系统调用exit函数结束自己的生命的时候，并没有真正的被销毁，而是留下一个称为僵尸进程（Zombie）的数据结构（系统调用exit，它的作用是使进程退出，但也仅仅限于将一个正常的进程变成一个僵尸进程，并不能将其完全销毁）。在这个退出过程中，进程占有的所有资源，除了task_struct结构（以及少数资源）以外将被回收。于是只剩下task_struct这么个空壳，故称为僵尸。
保留task_struct是因为task_struct里面保存了进程的退出码以及一些统计信息。其父进程很可能会关心这些信息。比如在shell中，$?变量就保存了最后一个退出的前台进程的退出码，而这个退出码往往被作为if语句的判断条件。内核也可以将这些信息保存在别的地方，而将task_struct结构释放掉，以节省一些空间。但是使用task_struct结构更为方便，因为在内核中已经建立了从pid到task_struct查找关系，还有进程间的父子关系。释放掉task_struct，则需要建立一些新的数据结构，以便让父进程找到它的子进程的退出信息。

在子进程中调用exit/return 可以终结子进程,但是这种终结不是销毁 ,子进程此时变成僵尸态。如果父进程一直没有去主动获取子进程的结束状态值,那么子进程就一直保持僵尸状态。通过wait/waitpid函数就可以获取退出状态值从而回收僵尸进程。一个进程在终止时会关闭所有文件描述符,释放在用户空间分配的内存,但它的PCB还保留着,内核在其中保存了一些信息:如果是正常终止则保存着退出状态,如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用wait或waitpid获取这些信息,然后清除掉这个进程。一个进程的退出状态可以在Shell中用特殊变量$?查看,因为Shell是它的父进程,当它终止时Shell调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。如果一个进程已经终止,但是它的父进程尚未调用wait或waitpid对它进行清理,这时的进程状态称为僵尸(Zombie)进程。任何进程在刚终止时都是僵尸进程。

销毁僵尸进程

父进程可以通过wait系列的系统调用（如wait、waitpid）来等待某个或某些子进程的退出，并获取它的退出信息。然后wait系列的系统调用会顺便将子进程的尸体（task_struct）也释放掉。父进程通过wait和waitpid等函数等待子进程结束，这会导致父进程挂起，相关用法可以通过man命令查看。

子进程在退出的过程中，内核会给其父进程发送一个信号，通知父进程来“收尸”。这个信号默认是SIGCHLD，但是在通过clone系统调用创建子进程时，可以设置这个信号。可以用signal函数为SIGCHLD安装handler回调函数，子进程结束后父进程会收到该信号，可以在handler中调用wait回收。

如果父进程不关心子进程什么时候结束，那么可以用signal（SIGCHLD,SIG_IGN）通知内核，自己对子进程的结束不感兴趣，那么子进程结束后内核会回收，并不再给父进程发送信号。fork两次，父进程fork一个子进程，然后继续工作，子进程fork一个孙进程后退出，那么孙进程被init接管，孙进程结束后init会回收。不过子进程的回收还要自己做。

僵尸进程和孤儿进程区别
僵尸进程: 一个进程使用fork创建子进程，如果子进程退出，而父进程没有调用wait或者waitpid获取子进程的状态，那么子进程的进程描述符仍然保存在系统中，这种进程称为僵尸进程。
孤儿进程: 父进程先于子进程结束,则子进程成为孤儿进程,子进程的父进程成为1号进程init进程，称为init进程领养孤儿进程。子进程的死亡需要父进程来处理，当父进程先于子进程死亡时，子进程死亡没有父进程处理，这个死亡的子进程就是孤儿进程。
僵尸进程占用一个进程ID号，占用资源，危害系统。孤儿进程与僵尸进程不同的是，由于父进程已经死亡，子系统会帮助父进程回收处理孤儿进程。所以孤儿进程实际上是不占用资源的，因为它最终是被系统回收了，不会像僵尸进程那样占用ID。

exit对_exit进行了一些包装，使得整个退出的过程显得不那么粗暴，共同点就是都会关闭文件描述符，都会清空内存，但是exit还会额外地清空输入输出流缓存，移除临时创建的文件，调用注册好的出口函数等等。

wait()函数功能是：父进程一旦调用了wait就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。

4.(TASK_DEAD - EXIT_DEAD)，退出状态，进程即将被完全销毁?

进程在退出过程中也可能不会保留它的task_struct。比如这个进程是多线程程序中被detach过的进程。或者父进程通过设置SIGCHLD信号的handler为SIG_IGN，显式的忽略了SIGCHLD信号。（这是posix的规定，尽管子进程的退出信号可以被设置为SIGCHLD以外的其他信号）此时进程将被置于EXIT_DEAD退出状态，这意味着接下来的代码立即就会将该进程彻底释放。所以EXIT_DEAD状态是非常短暂的，几乎不可能通过ps命令捕捉到。