【Linux/C++多进程篇(一) 】一个变两个？揭秘 C/C++ 程序中神奇的“分身术”

并发：针对于单核CPU系统在处理多个任务时，使用相关的调度机制，实现多个任务进行细化时间片轮询时，在宏观上感觉是多个任务同时执行的操作，同一时刻，只有一个任务在被CPU处理

并行：是针对于多核CPU而言，处理多个任务时，同一时间，每个CPU处理的任务之间是并行的，实现的是真正意义上多个任务同时执行的

三、进程的内存管理

此处我们就用一图来带大家快速了解我们进程中的内存管理

我们先从左往右来看，我们的操作系统是会通过物理内存来进行映射产生虚拟内存，而我们的虚拟内存中又分为3g的用户空间与1g的内核空间

从图中也不难看出，我们的用户空间其实就是我们之前经常所讲的那些内存分配的占用空间，而内核空间其实就是我们操作其他内核代码与数据存储的地方

物理内存：内存条上（硬件上）真正存在的存储空间
虚拟内存：程序运行后，通过内存映射单元，将物理内存映射出4G的虚拟内存，供进程使用

四、进程与程序的区别

进程：是动态的，进程是程序的一次执行过程，是有生命周期的，进程会被分配0--3G的用户空间，进程是在内存上存着的
程序：是静态的，没有所谓的生命周期，程序存储在磁盘设备上的二进制文件

五、进程的种类

进程一共有三种：交互进程、批处理进程、守护进程

1> 交互进程：它是由shell控制，可以直接和用户进行交互的，例如vim文本编辑器

2> 批处理进程：内部维护了一个队列，被放入该队列中的进程，会被统一处理。例如 g++编译器的一步到位的编译

3> 守护进程：脱离了终端而存在，随着系统的启动而运行，随着系统的退出而停止。例如：操作系统的服务进程

特性	交互进程	批处理进程	守护进程
与终端关系	必须关联一个终端（控制终端）	通常不关联终端（或与终端无关）	脱离终端，无控制终端
用户交互	实时交互，等待用户输入	无交互，按预设脚本执行	无直接用户交互，响应系统请求
运行方式	前台或后台（但前台居多）	后台运行（作业队列）	后台运行，常驻内存
生命周期	用户会话期间，用户退出则结束	作业执行完即结束	系统启动到关闭，长期运行
调度优先级	通常较高（响应性要求）	可低可高，取决于作业调度	通常后台优先级，但重要服务可调高
例子	bash、vim、top	`at`作业、`batch`作业、`g++`编译任务	sshd、httpd、cron

六、进程PID

那有了进程后，我们的进程之间该怎么区分谁是大哥，谁是二弟呢？这时候就靠我们的进程号 PID 了。

1> PID（Process ID）:进程号，进程号是一个大于等于0的整数值，是进程的唯一标识，不可能重复。

2> PPID(Parent Process ID):父进程号，系统中允许的每个进程，都是拷贝父进程资源得到的

3> 在linux系统中的 /proc目录下的数字命名的目录其实都是一个进程

当然，我们的PID肯定是有获取方法的，我们待会就会讲到。

七、特殊的进程

0号进程（idel）：他是由linux操作系统启动后运行的第一个进程，也叫空闲进程，当没有其他进程运行时，会运行该进程。他也是1号进程和2号进程的父进程
1号进程（init）：他是由0号进程创建出来的，这个进程会完成一些硬件的必要初始化工作，除此之外，还会收养孤儿进程
2号进程（kthreadd）：也称调度进程，这个进程也是由0号进程创建出来的，主要完成任务调度问题
孤儿进程：当前进程还正在运行，其父进程已经退出了。

说明：每个进程退出后，其分配的系统资源应该由其父进程进行回收，否则会造成资源的浪费

僵尸进程：当前进程已经退出了，但是其父进程没有为其回收资源

八、linux中有关进程的指令

ps指令：能够查看当前运行的进程相关属性

ps -ef :能够显示进程之间的关系

UID：用户ID号 ps -ajx:能够显示当前进程的状态

PID：进程号

PPID：父进程号

C：用处不大

STIME：开始运行的时间

TTY：如果是问号表示这个进程不依赖于终端而存在

CDM：名称

ps -ajx:能够显示当前进程的状态

PGID：进程组ID

SID：会话组ID

STAT：进程的状态

ps -aux:可以查看当前进程对CPU和内存的占用率

%CPU：CPU占用率

%MEM：内存占用率

top指令：动态查看进程的相关属性

此处，表里面的内容其实是会实时变化的，所以叫做动态查看。

kill指令：发送信号的指令

kill -信号号进程号

可以通过指令：kill -l查看能够发送的信号有哪些

1、从图可知一共可以发射62个信号，而前32个是稳定信号，后面剩余的是不稳定信号

2、常用的信号

SIGHUP：当进程所在的终端被关闭后，终端会给运行在当前终端的每个进程发送该信号，默认结束进程

SIGINT：中断信号，当用户键入ctrl + c时发射出来

SIGQUIT：退出信号，当用户键入ctrl + /是发送，退出进程

SIGKILL：杀死指定的进程

SIGSEGV：当指针出现越界访问时，会发射，表示段错误

SIGPIPE：当管道破裂时会发送该信号

SIGALRM：当定时器超时后，会发送该信号

SIGSTOP：暂停进程，当用户键入ctrl+z时发射

SIGTSTP：也是暂停进程

SIGTSTP、SIGUSR2 ：留给用户自定义的信号，没有默认操作

SIGCHLD：当子进程退出后，会向父进程发送该信号

3、有两个特殊信号：SIGKILL和SIGSTOP，这两个信号既不能被捕获，也不能被忽略

pidof：查看进程的进程号

pidof 进程名

九、进程状态的切换

可以通过 man ps 进行查看进程的状态

进程主状态：

D uninterruptible sleep (usually IO) 不可中断的休眠态，通常是IO操作

R running or runnable (on run queue) 运行态

S interruptible sleep (waiting for an event to complete) 可中断的休眠态

T stopped by job control signal 停止态

t stopped by debugger during the tracing 调试时的停止态

W paging (not valid since the 2.6.xx kernel) 已经弃用的状态

X dead (should never be seen) 死亡态

Z defunct ("zombie") process, terminated but not reaped by its parent 僵尸态

附加态：

< high-priority (not nice to other users) 高优先级进程

N low-priority (nice to other users) 低优先级进程

L has pages locked into memory (for real-time and custom IO) 锁在内存中的进程

s is a session leader 会话组组长

l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do) 包含多线程的进程

+ is in the foreground process group 前台运行的进程

状态切换的实例

进程主要状态的转换（五态图）

多进程的实现

进程的创建过程，是子进程通过拷贝父进程得到的，新进程的创建直接拷贝父进程的资源，只需改变很少部分的数据即可，保留了父进程的大部分的数据信息（遗传基因），所以这个拷贝过程，系统通过一个函数fork来自动完成

📖 进程的创建：fork

函数原型	pid_t fork(void);
头文件	unistd.h
功能	通过拷贝父进程得到一个子进程
参数说明	无
返回值	成功在父进程中得到子进程的pid，在子进程中的到0，失败返回-1并置位错误码

那如果有多个fork呢？大家可以先猜一下，下图程序运行后我们的进程总共有多少个，会是4个吗？如果有人觉得是4个，那不妨想想，我们的程序是不是从第9行开始创建新的进程，那么新进程将会从第10行开始运行。那么这时候，你还会觉得是4个进程吗？此时我们的进程其实就是8个。

如果不关注返回值的话，有n个fork，会产生2^n个进程

那么，fork函数的返回值在上面的表格中我们也说过了，现在我们来看看关注返回值的情况

#include<iostream> #include<cstdio> #include<cstring> #include <sys/types.h> #include <unistd.h> using namespace std; int main(int argc, const char *argv[]){ pid_t pid = -1; //对于父进程而言会得到大于0的数字，对于子进程而言会得到0 pid = fork(); //创建一个子进程，父进程会将返回值赋值给父进程中的pid变量 //子进程会将返回值赋值给子进程中的pid变量 printf("pid = %d\n", pid); //对pid进程判断 if(pid > 0){ //父进程要做执行的代码 printf("我是父进程\n"); }else if(pid == 0){ //子进程要执行的代码 printf("我是子进程\n"); }else{ perror("fork error"); return -1; } while(1); return 0; }

对于上述的程序，我们的结果如下

那我们现在就可以进行父子进程的并发执行案例了

#include<iostream> #include<cstdio> #include<cstring> #include <sys/types.h> #include <unistd.h> using namespace std; int main(int argc, const char *argv[]){ pid_t pid = -1; pid = fork(); //创建一个子进程，父进程会将返回值赋值给父进程中的pid变量 //子进程会将返回值赋值给子进程中的pid变量 //对pid进程判断 if(pid > 0){ while(1){ //父进程要做执行的代码 printf("我是父进程1111\n"); sleep(1); } }else if(pid == 0){ while(1){ //子进程要执行的代码 printf("我是子进程\n"); sleep(1); } }else{ perror("fork error"); return -1; } return 0; }

值得一提的是，我们可以看看我们执行的结果：

📖 父子进程号的获取：getpid、getppid

函数原型	pid_t getpid(void);	pid_t getppid(void)
头文件	sys/types.h unistd.h	sys/types.h unistd.h
功能	获取当前进程的进程号	获取当前进程的父进程pid号
参数说明	无	无
返回值	当前进程的进程号	当前进程的父进程pid

📖 进程退出：exit/_exit

上述两个函数都可以完成进程的退出，区别是在退出进程时，是否刷新标准IO的缓冲区

exit属于库函数，使用该函数退出进程时，会刷新标准IO的缓冲区后退出

_exit属于系统调用（内核提供的函数），使用该函数退出进程时，不会刷新标准IO的缓冲区

函数原型	void exit(int status);	void _exit(int status);
头文件	stdlib.h	stdlib.h
功能	退出当前进程，并刷新当前进程打开的标准IO的缓冲区	退出当前进程，不刷新当前进程打开的标准IO的缓冲区
参数说明	进程退出时的状态，会将改制与 0377进行位与运算后，返回给回收资源的进程	进程退出时的状态，会将改制与 0377进行位与运算后，返回给回收资源的进程
返回值	无	无

📖 进程资源回收：wait、waitpid

有两个函数可以完成对进程资源的回收

wait：阻塞回收任意一个子进程的资源函数

waitpid：可以阻塞，也可以非阻塞完成对指定的进程号进程资源回收

函数原型	void exit(int status);	void _exit(int status);
头文件	sys/types.h sys/wait.h	sys/types.h sys/wait.h
功能	阻塞回收子进程的资源	可以阻塞也可以非阻塞回收指定进程的资源
参数说明	接收子进程退出时的状态，获取子进程退出时的状态与0377进行位与后的结果，如果不愿意接收，可以填NULL	参数1：进程号 >0:表示回收指定的进程，进程号位pid（常用） =0：表示回收当前进程所在进程组中的任意一个子进程 =-1：表示回收任意一个子进程（常用） <-1:表示回收指定进程组中的任意一个子进程，进程组id为给定的pid的绝对值参数2：接收子进程退出时的状态，获取子进程退出时的状态与0377进行位与后的结果，如果不愿意接收，可以填NULL 参数3：是否阻塞 0：表示阻塞等待 WNOHANG：表示非阻塞
返回值	成功返回回收资源的那个进程的pid号，失败返回-1并置位错误码	>0: 返回的是成功回收的子进程pid号 =0:表示本次没有回收到子进程 =-1：出错并置位错误码

#include<iostream> #include<cstdio> #include<cstring> #include <sys/types.h> #include <unistd.h> #include <sys/wait.h> using namespace std; int main(int argc, const char *argv[]){ pid_t pid = -1; //定义用于存储进程号的变量 //创建进程 pid = fork(); if(pid > 0) { //父进程程序代码 //输出当前进程号、子进程号、父进程号 printf("self pid=%d, child pid = %d, parent pid = %d\n", getpid(), pid, getppid()); sleep(8); //休眠3秒 //wait(NULL); //回收子进程资源,只有回收了子进程资源后，父进程才继续向后执行 waitpid(-1, NULL, WNOHANG); //非阻塞回收子进程资源 printf("子进程资源已经回收\n"); } else if(pid == 0) { //子进程程序代码 //输出当前进程的进程号、父进程进程号 printf("self pid = %d, parent pid = %d\n", getpid(), getppid()); //提出子进程 printf("11111111111111111111111111111111111"); //没有加换行，不会自动刷新 sleep(3); exit(EXIT_SUCCESS); //刷新缓冲区并退出进程 //_exit(EXIT_SUCCESS); //不刷新缓冲区退出进程 } else { perror("fork error"); return -1; } while(1); //防止进程退出 return 0; }

下图为运行效果

📖 僵尸进程和孤儿进程

孤儿进程：当前进程还正在运行，其父进程已经退出了。

每个进程退出后，其分配的系统资源应该由其父进程进行回收，否则会造成资源的浪费

我们不妨来看看，父进程不回收资源会发生什么

#include<iostream> #include<cstdio> #include<cstring> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <sys/wait.h> using namespace std; int main(int argc, const char *argv[]){ pid_t pid = fork(); if(pid > 0){ sleep(5); exit(EXIT_SUCCESS); }else if(pid == 0){ while(1){ printf("我是子进程\n"); sleep(1); } }else{ perror("fork error"); return -1; } return 0; }

可以看到在 Linux 中，孤儿不会流落街头。它们会被系统的“福利院院长”—— init 进程 (PID 1) 收养。init 进程会定期帮它们收尸，所以孤儿进程通常无害。

僵尸进程：当前进程已经退出了，但是其父进程没有为其回收资源

#include<iostream> #include<cstdio> #include<cstring> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <sys/wait.h> using namespace std; int main(int argc, const char *argv[]){ pid_t pid = fork(); if(pid > 0){ while(1){ printf("我是父进程\n"); sleep(1); } }else if(pid == 0){ sleep(5); exit(EXIT_SUCCESS); }else{ perror("fork error"); return -1; } return 0; }

效果如下：

深度解析：fork中的黑魔法

那么学完应用方面，再给大家提一点点细枝末节。

我相信很多初学者以为 fork() 是把整个程序从头到尾复制了一遍，就像复印机一样。
那你就错了，如果每次分身都完整复制几 GB 的内存，电脑早就卡死了。

操作系统（OS）使用了一个极其聪明的机制：写时复制 (Copy-On-Write, COW)。

通俗解释 COW：

分身瞬间：
- 父进程和子进程共享同一块物理内存。
- OS 只是把这块内存标记为“只读”，并给父子进程各自发了一本新的“地图”（页表）。
- 此时，没有发生任何数据拷贝！速度极快，几乎瞬间完成。
读取数据时：
- 父子进程去读变量 int a = 10;。
- 因为大家读的都是同一块只读内存，完全没问题，继续共享。
修改数据时（关键点！）：
- 假设子进程说：“我要把 a 改成 20”。
- OS 拦截了这个操作（触发缺页中断）。
- OS 心想：“你要改？行，那我单独给你复印一份这一页内存，你在你的副本上随便改，别影响你爸。”
- 只有在这时，真正的内存拷贝才发生。

那么现在再来想这么一个问题：fork之后，父子进程的内存关系吗？如果我在 fork 前定义了一个全局变量，fork 后子进程改了它，父进程会变吗？

这个问题的核心就在于理解 Copy-On-Write (写时复制) 机制。

        首先，当调用 fork() 时，操作系统并没有立即在物理内存中复制一份父进程的数据。父子进程在初始阶段是共享同一块物理内存页的，只不过这些页被标记为了只读。此时，如果父子进程都只是读取那个全局变量，它们访问的是同一个物理地址，效率极高。

        其次，关键在于写入。当子进程尝试修改这个全局变量时，CPU 会触发一个缺页异常（Page Fault）。操作系统内核捕获到这个异常后，意识到子进程要‘写’了，于是它会真正地为子进程分配一块新的物理内存，将原数据复制过去，然后让子进程在新的内存页上修改。而父进程的页表依然指向原来的物理内存。

        所以我们的结论就出来了：读操作：父子进程共享物理内存，互不影响（因为都没改）。写操作：一旦发生写操作，内存即刻分离。子进程修改变量，绝对不会影响父进程的值，因为它们此刻已经指向了不同的物理地址。

这种机制既保证了进程间的隔离性（数据安全），又极大优化了性能（避免了不必要的拷贝）。这也是为什么在 C++ 后端中，即使创建大量进程，系统开销也是可控的原因。

结语

今天我们揭开了 C++ 多进程“分身术”的面纱：

fork() 是咒语。
COW 是省钱的秘诀。
返回值 是身份的证明。
wait 是负责任的态度。

但这只是开始。两个独立的进程，如果想互相传个话（比如父进程告诉子进程“该下班了”），或者传个大文件，该怎么办？它们不能直接读对方的内存，那就要用到更有趣的 IPC（进程间通信）技术了：管道、消息队列、共享内存，我们下一篇文章将会带来这些内容的讲解

我是YYYing，后面还有更精彩的内容，希望各位能多多关注支持一下主包。

无限进步，我们下次再见！

【Linux/C++多进程篇(一) 】一个变两个？揭秘 C/C++ 程序中神奇的“分身术”

Ne0inhk

前言：

多进程理论基础

一、为什么要引入多进程

二、多进程相关概念