fork
子进程复制父进程的0到3g空间和父进程内核中的PCB，但id号不同。
程序一讲解：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
//fork创建一个新进程
pid_t p1 = -1;
//fork之前的操作只有父父进程才有
p1 = fork(); //调用一次fork函数会返回两次
if(p1 == 0)
{
//这里一定是子进程
//先sleep一下，让父进程先死
sleep(1);
printf("子进程, pid = %d.\n", getpid());
printf("子进程, p1 = %d.\n", p1);
printf("子进程中父进程的ID = %d.\n", getppid());
}
if(p1 > 0)
{
//这里一定是父进程
printf("父进程, pid = %d.\n", getpid());
printf("父进程, p1 = %d.\n", p1);
}
if(p1 < 0)
{
//这里一定是出错了
}
//在这里的操作，父子进程都有
//printf("hello world, pid = %d.\n", getpid());
return 0;
}输出结果如下
结论：
（1）fork函数调用一次会返回两次，返回值等于0的就是子进程，返回值大于0的就是父进程
（2）fork的返回值在子进程中等于0， 在父进程中返回值等于本次fork创建的子进程的PID
（3）这里在子进程中打印父进程PID，为什么跟在父进程中打印父进程的PID结果不一样？
是因为在执行的时候，父进程先执行完，然后子进程就没有父进程了；这是在子进程中打印的父进程PID就是init进程
程序二讲解：
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
int main(void)
{
pid_t pid ;
//调用一次返回2次，在父进程返回子进程的PID，在子进程中返回0
int n = 10;
pid = fork();
if(pid > 0)
{/*in parent*/
while(1)
{
printf("I am parent %d\n", n++);
printf("my pid = %d.\n", getpid());
printf("my parent pid = %d.\n", getppid());
sleep(1);
}
}
else if(pid == 0)
{/*in child*/
while(1)
{
printf("I am child %d\n", n++);
printf("my pid = %d.\n", getpid());
printf("my parent pid = %d.\n", getppid());
sleep(3);
}
}
else
{
perror("fork");
exit(0);
}
return 0;
}（1）父子进程中n值分别独立加，说明子进程从父进程中克隆过来的数据，已经不是共享的了。两者有自己独立的空间。
（2）0-3G放应用层代码，子进程直接从父进程中拷贝，3-4G是内核空间
（3）读时共享，写时复制
fork创建了子进程之后，调用exec函数执行子进程
exec函数
用fork创建子进程后执行的是和父进程相同的程序，可以通过if判断pid的返回值让子进程执行不同的代码分支，这样设计程序不灵活。通过调用exec函数，用新程序将子进程的用户空间代码和数据替换，直接去执行新程序。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。
其实有六种以exec开头的函数，统称exec函数：
#include <unistd.h>
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回，如果调用出错
则返回-1，所以exec函数只有出错的返回值而没有成功的返回值。
程序1：
#include <stdio.h>
#include <unistd.h>
int main(void)
{
printf("hello.\n");
execl("/bin/ls", "ls", "-l", NULL);
printf("world.\n");
return 0;
}执行结果：
分析：
可以看到没有执行 printf(“world.\n”);
这是因为/bin/ls加载到用户用户空间替换了原来代码段，所以execl下面的代码就不会执行了。所以程序是从ls的return 0退出程序的。
函数辨析
execl与execlp
execl("/bin/ls", "ls", "-l", NULL);
execlp("ls", "ls", "-l", NULL);
execl要给全执行进程的路径，而execlp除了在当前路径下找，还可以去PATH环境变量底下找。p就是去环境变量底下找，不加p就是在当前路径下找，所以要给全路径
execv与execvp
这两个函数的功能跟excel与execlp的功能一样，只是将参数列表以数组指针的方式给出。
还是用上面执行ls举例
char *argvv[] = {“ls”, “-l”, NULL};
execv(“/bin/ls”, argvv); execvp(“ls”, argvv);
execle execve中添加了一个替换环境变量的参数，在加载新的程序的时候，我们可以不用原来的环境变量。（这两个函数实际用的很少）
wait & waitpid
僵尸进程
(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”，在这一段（子进程已经结束且父进程尚未帮其收尸）子进程就被称为僵尸进程。
(2)子进程除 task_struct 和栈外其余内存空间皆已清理
(3)父进程可以使用 wait 或 waitpid 以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。【父进程帮子进程收尸是要调用函数的】
(4)父进程也可以不使用 wait 或者 waitpid 回收子进程，此时父进程结束时一样会回收子进程的剩余待回收内存资源。（这样设计是为了防止父进程忘记显式调用 wait/waitpid 来回收子进程从而造成内存泄漏）
孤儿进程
(1)父进程先于子进程结束，子进程成为一个孤儿进程。
(2)linux 系统规定：所有的孤儿进程都自动成为一个特殊进程（进程 1，也就是 init 进程）的子进程。
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);wait返回值：成功回收子进程，返回终止的子进程的pid，错误返回-1
（1）waitpid参数含义：
| 参数值 |
含义 |
| pid<-1 |
等待进程组号为pid绝对值的任何子进程。 |
| pid=-1 |
等待任何子进程，此时的waitpid()函数就退化成了普通的wait()函数。 |
| pid=0 |
等待进程组号与目前进程相同的任何子进程，也就是说任何和调用waitpid()函数的进程在同一个进程组的进程。 |
| pid>0 |
等待进程号为pid的子进程。 |
（2）int *status
这个参数将保存子进程的状态信息，有了这个信息父进程就可以了解子进程为什么会退出，是正常退出还是出了什么错误。如果status不是空指针，则状态信息将被写入寄存器指向的位置。当然，如果不关心子进程为什么推出的话，也可以传入空指针。
Linux提供了一些非常有用的宏来帮助解析这个状态信息，这些宏都定义在sys/wait.h头文件中。主要有以下几个：
| 宏 |
说明 |
| WIFEXITED(status) |
如果子进程正常结束，它就返回真；否则返回假。 |
| WEXITSTATUS(status) |
如果WIFEXITED(status)为真，则可以用该宏取得子进程exit()返回的结束代码。 |
| WIFSIGNALED(status) |
如果子进程因为一个未捕获的信号而终止，它就返回真；否则返回假。 |
| WTERMSIG(status) |
如果WIFSIGNALED(status)为真，则可以用该宏获得导致子进程终止的信号代码。 |
| WSTOPSIG(status) |
如果当前子进程被暂停了，则返回真；否则返回假。 |
| WIFSTOPPED(status) |
如果WIFSTOPPED(status)为真，则可以使用该宏获得导致子进程暂停的信号代码。 |
（3）int options
参数options提供了一些另外的选项来控制waitpid()函数的行为。如果不想使用这些选项，则可以把这个参数设为0。主要使用的有以下两个选项：
| 参数 |
说明 |
| WNOHANG |
如果pid指定的子进程没有结束，则waitpid()函数立即返回0，而不是阻塞在这个函数上等待；如果结束了，则返回该子进程的进程号。 |
| WUNTRACED |
如果子进程进入暂停状态，则马上返回。 |
这些参数可以用“|”运算符连接起来使用。
如果waitpid()函数执行成功，则返回子进程的进程号；如果有错误发生，则返回-1，并且将失败的原因存放在errno变量中。
失败的原因主要有：没有子进程（errno设置为ECHILD），调用被某个信号中断（errno设置为EINTR）或选项参数无效（errno设置为EINVAL）
如果像这样调用waitpid函数：waitpid(-1, status, 0)，这此时waitpid()函数就完全退化成了wait()函数。
程序1
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <wait.h>
int main(void)
{
pid_t pid, pid_c;
//调用一次返回2次，在父进程返回子进程的PID，在子进程中返回0
int n = 10;
pid = fork();
if(pid > 0)
{/*in parent*/
while(1)
{
printf("I am parent pid = %d\n", getpid());
pid_c = wait(NULL); //wait是一个阻塞函数，等待回收子进程资源
//如果没有子进程，wait返回-1
printf("wait for child %d.\n", pid_c);
sleep(1);
}
}
else if(pid == 0)
{/*in child*/
//printf("I am child %d\n", n++);
printf("I am child pid = %d.\n", getpid());
//printf("my parent pid = %d.\n", getppid());
sleep(10);
}
else
{
perror("fork");
exit(0);
}
return 0;
}编译之后，程序执行结果如下：
刚进来的时候打印一次父子进程的ID号，然后子进程slepp 10s，父进程执行wait等待回收子进程，阻塞在这里，直到子进程结束。子进程结束之后，wait的返回值就是-1.
僵尸进程对内存的影响：子进程如果没有回收，子进程占了一个PCB，浪费内存，造成内存泄露。
程序2：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <wait.h>
int main(void)
{
pid_t pid;
int n = 3;
while(n--)
{
pid = fork();
if(pid == 0) break;
}
if(pid == 0)
{
//while(1)
{
printf("I am child %d.\n", getpid());
sleep(3);
}
}
else if(pid > 0)
{
pid_t pid_c;
while(1){
//pid_c = wait(NULL);
printf("I am parent.\n");
pid_c = waitpid(0, NULL, WNOHANG);
if(pid_c == -1)
continue;
else
printf("wait for child %d.\n", pid_c);
if(pid_c > 0){
n++;
}
if(n == 2)
break;
sleep(1);
}
}
return 0;
}一个父进程fork了三个子进程，通过ps – ajx查看
可以看到三个子进程的pid号依次递增，，父进程与三个子进程同属于一个进程组。（父进程创建子进程之后，子进程跟父进程默认是一个组）
如何kill掉一个进程组，命令【kill -9 -14943】
注释掉while(1)，执行之后可以看到，通过WNOHANG确实将waitpid设置成了非阻塞的。
