# 写在前面
本文主要介绍一些`Linux`系统编程中进程控制的一些函数
# fork
作用：用于从一个已存在的进程中创建一个新进程，新进程称为子进程，原进程称为父进程。
函数原型：pid_t fork(void);
需要的头文件：
- #include <unistd.h>
- #include <sys/types.h>
返回值：
- 成功：
- 在子进程中返回 0
- 在父进程中返回创建的子进程的`pid`
- 失败：返回-1，并设置`errno`
- 当前的进程数已经达到了系统规定的上限，这时 `errno` 的值被设置为 `EAGAIN`。
- 系统内存不足，这时 `errno` 的值被设置为 `ENOMEM`。
## 案例
```c
#include<stdio.h>
#include <unistd.h>
#include <error.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
pid_t pid;
pid = fork();
if(pid < 0){
perror("fork error");
exit(1);
} else if(pid == 0){
printf("I am child my pid is %d\n", getpid()); //getpid函数用于获取当前进程的pid
} else {
printf("I am parent my pid is %d\n", getpid());
}
return 0;
}
```
程序运行结果如下
从运行结果，我们可以看出，`fork()` 之后的打印函数打印了两次，而且打印了两个进程号，这说明，`fork()` 之后确实创建了一个新的进程，新进程为子进程，原来的进程为父进程。
那子进程长什么样的呢？
使用 `fork()` 函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间：包括进程上下文（进程执行活动全过程的静态描述）、进程堆栈、打开的文件描述符、信号控制设定、进程优先级、进程组号等。子进程所独有的只有它的进程号，计时器等（只有小量信息）。因此，使用 `fork()` 函数的代价是很大的。
简单来说， 一个进程调用 `fork()` 函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。
实际上，更准确来说，`Linux` 的 `fork()` 使用是通过写时拷贝 (copy- on-write) 实现。写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。也就是说，<font color="#FF0000">资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享,**读时共享，写时复制**</font>。
- 父子进程相同：刚`fork`后父子 data段、text段、堆、栈、环境变量、全局变量、宿主目录位置、进程工作目录位置、信号处理方式
- 父子进程不同：
进程id、返回值、各自的父进程、进程创建时间、闹钟、未决信号集
- 父子进程共享：读时共享、写时复制。———————— 全局变量。
- 文件描述符
- mmap映射区
# 获得进程号
函数：
- pid_t getpid(void);
- 作用： 获取本进程号（PID）
- pid_t getppid(void);
- 作用：获取调用此函数的进程的父进程号（PPID）
- pid_t getpgid(pid_t pid);
- 作用：获取进程组号（PGID）
- 参数：参数为 0 时返回当前进程组号，否则返回参数指定的进程的进程组号
头文件：
- #include <sys/types.h>
- #include <unistd.h>
## 案例
循环创建子进程。在前面提到过，创建子进程的过程是一个树型的过程，如果单单使用循环去创建的话，过程大概如下
从上图可以看出，当`n=2`时，创建了 $2^n - 1$个子进程，而不是 $n$ 个子进程，所以循环创建子进程的代码如下
```c
#include<stdio.h>
#include <unistd.h>
#include <error.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
pid_t pid;
int i = 0;
for(i = 0;i < 5;i++){
pid = fork();
if(pid == 0)
break;
}
if(pid < 0){
perror("fork error");
exit(1);
} else if(pid == 0){
printf("I am %dth child my pid is %d\n",i+1, getpid());
} else {
printf("I am parent\n");
}
return 0;
}
```
执行结果如下，因为在CPU看来所有进程都是同时产生的，所以进程的调度是随机的，谁先抢到CPU的资源谁就先打印自己的`pid`
# vfork
作用：vfork() 函数和 fork() 函数一样都是在已有的进程中创建一个新的进程，但它们创建的子进程是有区别的
返回值：
- 成功：子进程中返回 0，父进程中返回子进程 ID。`pid_t`，为无符号整型。
- 失败：返回 -1，设置`errno`
<font color="#008000">fork() 与 vfock() 都是创建一个进程，那它们有什么区别呢？</font>
> 1. 父子执行程序的顺序，通过`fork()`出来的子进程与父进程执行的顺序由CPU随机决定，而通过`vfork`出来的保证子进程先运行，在它调用`exec`族函数与`exit`之后父进程才可能被调度运行。
> 2. fork()： 子进程拷贝父进程的地址空间，子进程是父进程的一个复制品。
vfork()：子进程共享父进程的地址空间（准确来说，在调用 exec（进程替换） 或 exit（退出进程） 之前与父进程数据是共享的）
## 案例
```c
#include<stdio.h>
#include <unistd.h>
#include <error.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
int a = 20;
int main(int argc, char *argv[]){
pid_t pid;
int b = 50; //在父进程中创建两个变量
pid = vfork();
if(pid < 0){
perror("fork error");
exit(1);
} else if(pid == 0){
sleep(3);//让子进程睡三秒
a = 200;
b = 500;
printf("I am child a = %d b = %d\n",a, b);
exit(1);
} else {
printf("I am parent a = %d b = %d\n", a, b);
}
return 0;
}
```
从程序的执行结果来看，子进程在没调用`exit`以前，即使睡眠父进程仍然要等子进程结束才能运行，且当变量在子进程内更改，父进程内变量的地址也被更改。
`vfork()` 保证子进程先运行，在它调用 `exec`（进程替换） 或 `exit`（退出进程）之后父进程才可能被调度运行。<font color="#DC143C">如果子进程没有调用 exec, exit, 程序则会导致死锁，程序是有问题的程序</font>，没有意义，所以<font color="#DC143C">用 vfork() 创建进程，子进程里一定要调用 exec（进程替换） 或 exit（退出进程）</font>。
# 父子进程的调试
父子进程的GDB调试
> 设置父进程调试路径：set follow-fork-mode parent (默认)
> 设置子进程调试路径：set follow-fork-mode child
创建子进程
