一、进程创建
1、初识fork()函数
在Linux中，fork函数是非常重要的函数，它从已存在的进程中创建一个新进程。这样，新进程为子进程，原进程为父进程。
（1）调用fork函数的格式，如下：
#include <unistd.h>
#include <sys/types.h>
pid_t fork(void);
返回值：子进程返回0；父进程返回子进程的PID；出错返回-1。 （2）调用fork函数后，内核的工作：
1)分配新的内存块和内核数据结构给子进程。
2)将父进程的部分数据结构内容拷贝至子进程。
3)添加子进程到系统进程列表中。
4)fork返回,调度器开始调度。
总之：子进程是父进程的一个副本，将获得父进程的数据段、代码段、用户段、堆、共享库和文件描述符。由于具有相同的文件描述符，所以子进程可以读写父进程中的任何文件。
注意：当一个进程调用fork之后，就有两个二进制代码相同的进程，而且它们都运行到相同的地方，但是每个进程都可以开始它们自己的旅程。也就是说，fork被调用一次，返回两次。看如下程序：
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
pid_t pid;
printf("Before: pid is %d\n", getpid());
if((pid=fork()) == -1)perror("fork()"),exit(1);
printf("After:pid is %d, fork return %d\n", getpid(),pid);
sleep(1);
return 0;
}运行结果：
释：
这里有三行输出，一行before，两行after。进程2785先打印before信息，然后再打印after，另一个after由2786打印。但是，进程2786没有打印before，为什么呢？因为，fork之前，父进程独立执行；fork之后，父子进程两个执行流分别执行。
注意：
fork之后谁先执行，完全由调度器决定。
2、存储方式：写时拷贝
通常，父子进程代码共享，父子进程不再写入时，数据也是共享的。当任意一方试图写入，便以写时拷贝的方式各自存有一份副本。
3、fork常规用法：
（1）一个父进程希望赋值自己，是父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
（2）一个进程要执行一个不同的程序。例如，子进程从fork返回后，调用exec函数。
4、fork调用失败的原因
（1）系统中有太多的进程。
（2）实际用户的进程数超过了限制。
5、vfork函数
（1）用于创建一个子进程，而子进程和父进程共享地址空间，fork的子进程具有独立的地址空间。
（2）vfork保证子进程先执行，在它调用exec或（exit）之后父进程才可能被调度运行。
【例】
#include<stdio.h>
#include<stdlib.h>
int glob = 0;
int main()
{
pid_t pid;
if ((pid=vfork()) == -1)perror("fork"),exit(1);
if(pid == 0){//child
sleep(1);
glob = 6;
printf("child glod %d\n", glob);
exit(0);
}else{//parent
printf("parent glob %d\n", glob);
}
return 0;
}运行结果：
释：子进程直接改变了父进程的变量值，因为子进程在父进程的地址空间中运行。
二、进程终止
1、进程退出的情况
（1）代码运行完毕，结果正确；
（2）代码运行完毕，结果错误；
（3）代码异常终止。
2、常见的进程退出方法
（1）正常终止
1）从主函数（main）返回
2）调用_exit函数
#include<unistd.h>
void _exit(int status);
参数：status定义了进程的终止状态，父进程通过wait来获取该值。
说明：虽然status是int，但是仅有低8位可以被父进程所利用，所有_exit(-1)时，在终端执行$?发现返回值是255。 3）调用exit函数
A、exit函数应用格式：
#include<unistd.h>
void exit(int status);
B、调用exit前的工作
a、执行用户定义的atexit或on_exit清理函数。
b、关闭所有打开的流，所有的缓存数据均被写入。
c、调用_exit。其过程如图所示：
d、return退出
return是一种更常见的退出进程方法。执行return等同于执行exit(n)，因为调用main函数时会将main的返回值当做exit的参数。
（2）异常退出：
Ctrl+c：信号终止
三、回收子进程–进程等待
1、进程等待的必要性：
僵尸子进程即使不运行，也会消耗系统的内存资源。父进程可通过进程等待的方式回收子进程，获取子进程的退出信息，避免造成僵尸进程。
注：如果一个父进程终止了，内核会安排init进程成为它的孤儿进程的养父。init进程的PID为1，是在系统启动时内核创建的，它不会终止，是所有进程的祖先。一旦终止了，系统将关闭。
2、进程等待的方法：
（1）wait方法
工作格式：
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int status);释：
1）返回值：成功返回被等待的进程pid，失败返回-1。
2）参数：输出型参数，获取子进程退出状态，不关心则可以设置成为NULL。
（2）waitpid方法
工作格式：
pid_t waitpid(pid_t pid, int *statusp, int options);返回值：
1）当正常返回的时候，waitpid返回收集到的子进程的进程id；
2）如果设置了选项WNOHANG，而调用时waitpid发现没有已退出的子进程可收集，则返回0；
3）如果调用中出错，则返回-1。这时errno会被设置成相应的值以指示错误所在。
参数：
1)判断等待集合的成员：pid
A、当pid=-1，等待集合由父进程的所有子进程组成，与wait等效。
B、当pid>0，等待集合由一个单独的子进程组成，它的进程ID等于pid。
2）检查已收回子进程的退出状态：status
如果statusp的参数是非空的，那么waitpid就会在status中放上关于导致返回的子进程的状态信息，status是statusp指向的值。wait.h头文件定义了解释status参数的几个宏：
A、WIFEXITED（status）：若为正常终止子进程返回的状态，则为真。（查看进程是否正常退出）
B、WEXITSTATUS（status）：若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）。
3）修改默认行为：options
WNOHANG：若pid指定的子进程没有结束，则waitpid函数返回0，不予以等待；若正常结束，则返回孩子进程ID。
4）注意：
A、如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回-1，还会设置errno为ECHILD，并且释放资源和获得子进程的退出信息。
B、如果在任意时刻调用wait/waitpid，子进程存在且正常进行，则进程可能阻塞。
C、如果waitpid函数被一个信号中断，那么它会返回-1，并设置errno为EINTR。
（3）获取子进程的状态（status）
wait/waitpid都有一个status参数，该参数是一个输出型参数，有操作系统填充。如果传递NULL，表示不关心子进程的退出状态信息；否则，操作系统会根据该参数将子进程的退出信息反馈给父进程。status不能简单的当作位图来看待，具体细节如下图所示（只研究status低16位比特位）：
代码如下：
【例】
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<sys/wait.h>
int main()
{
pid_t pid;
if((pid=fork()) == -1)
perror("fork"),exit(1);
if(pid == 0){
sleep(6);
exit(3);
}else{
int st;
int ret = wait(&st);
if(ret > 0 && ( st & 0x7f ) == 0){//exit
printf("child exit code:%d\n", (st>>8)&0xff);
}else if(ret > 0){
printf("sig code : %d\n", st&0x7f);
}
}
}运行结果：
[hongji@localhost 11_20]$ ./a.out
child exit code:3
[hongji@localhost 11_20]$ 3、具体代码实现
【例1】进程的阻塞等待方式
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<sys/wait.h>
int main()
{
pid_t pid;
pid = fork();
if(pid < 0){
printf("%s fork error\n", __FUNCTION__);
return 1;
}else if(pid == 0){//child
printf("child is run, pid is : %d\n", getpid());
sleep(6);
exit(257);
}else{
int status = 0;
pid_t ret = waitpid( -1, &status, 0);//block wait 5s
printf("this is test for wait\n");
if(WIFEXITED(status) && ret == pid){
printf("wait child 5s success, child return code is :%d.\n", WEXITSTATUS(status));
}else{
printf("wait child failed, return.\n");
return 1;
}
}
return 0;
}运行结果：
【例2】进程非阻塞方式
“`
1 #include
运行结果：
【例3】使用waitpid函数不按照特定的顺序回收僵死子进程 1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<unistd.h>
4 #include<sys/wait.h>
5 #include<errno.h>
6 #define N 6
7
8 int main()
9 {
10 int i, status;
11 pid_t pid;
12
13 //parent create N children
14 for(i = 0; i < N; i++)
15 if(fork() == 0)
16 exit(100+i);
17
18 //parent reaps N children in no particular order
19 while((pid = waitpid(-1, &status, 0)) > 0){
20 if(WIFEXITED(status))
21 printf("child %d terminated normally\n", pid, WEXITSTATUS(status));
22 else
23 printf("child %d terminated abnormally\n", pid);
24 }
25
26 //The only narmal terminated is if there are no more children
27 if(errno != ECHILD)
28 perror("waitpid error"),exit(1);
29
30 exit(0);
31 }
运行结果：
【例4】使用waitpid按照创建子进程的顺序来回收这些僵死的子进程。
```
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<unistd.h>
4 #include<errno.h>
5 #include<sys/wait.h>
6 #define N 6
7
8 int main()
9 {
10 int status, i;
11 pid_t pid[N], retpid;
12
13 //parent create N children
14 for(i = 0; i < N; i++)
15 if((pid[i] = fork()) == 0)
16 exit(100+1);
17
18 //parent reaps N children in order
19 i = 0;
20 while((retpid = waitpid(pid[i++], &status, 0)) > 0){
21 if(WIFEXITED(status))
22 printf("child %d terminated normally with exit status=%d\n", retpid, WEXITSTATUS(status));
23 else
24 printf("child %d terminated abnomally\n", retpid);
25 }
26
27 //the only normal termination is if there are no more children
28 if(errno != ECHILD)
29 perror("waitpid error!\n"),exit(1);
30
31 return 0;
32 }运行结果：
