运维在群里发了一张截图:一台 8 核机器上跑着三百多个进程,其中一大半名字都相同。开发的第一反应是“谁把进程写漏了”,运维的第一反应是“先看看父进程是谁”。两个人说的都不是同一件事,但都指向同一个基础问题:进程到底是什么,它是从哪一步开始存在的?

这篇不讲定义,直接走一遍。你双击一个程序,到任务管理器里出现一个带 PID 的条目,中间发生了加载、映射、建线程、初始化这几步。把这几步看清了,后面遇到僵尸进程、句柄泄漏、强杀进程导致文件损坏,才知道该往哪里看。

现象:磁盘上的文件,和任务管理器里的条目

先把两个容易混的东西分开。你双击的那个 .exe 文件,是躺在磁盘上的一堆指令和数据,它不是进程。双击只是一个动作,真正干活的是文件资源管理器:它拿到你点的路径,调用系统接口,请求创建一个新进程。

于是任务管理器里出现了一个条目。这个条目背后至少包含四样东西:一个编号(PID),一块只有它能直接访问的地址空间,一张记录着打开了哪些文件、网络连接、注册表键的句柄表,以及至少一条正在执行的线程。进程本身不会“跑”,跑的是线程;进程只是这些资源的容器。

一个很直观的验证:同一个程序双击两次,任务管理器里会出现两个同名条目,PID 不同,占用的内存也不共享。它们各自有一份地址空间,改一个里面的全局变量,另一个完全不知道。这就是“程序是文件,进程是运行实例”最朴素的样子。

还有一个容易被忽略的细节:程序的第一行代码还没执行,任务管理器里就已经有它了。因为进程对象是先被创建出来的,主线程随后才开始跑。换句话说,进程的出生和程序的开始,不是同一时刻。

场景走查:从一次点击到第一条指令

以 Windows 为例,把这条路拆成五步。

一次双击之后的五个阶段
发起创建explorer.exe 带着路径和命令行调用创建进程接口
建立容器内核创建进程对象、PID、句柄表和初始地址空间
映射镜像加载器读取 PE 头,把代码段、数据段映射进地址空间
加载依赖把运行库和系统 DLL 映射进来,解析导入表
启动线程创建主线程,从运行库入口走到你的 main

第一步,文件资源管理器并不自己加载程序,它只是发起请求。请求里不只有路径,还有命令行参数、环境变量、工作目录、窗口显示方式。这些东西会原样进入新进程,所以“双击打开”和“命令行带参数打开”,最后拿到的初始状态可能完全不同。

第二步,内核接手。它要分配一个 PID,创建进程对象,准备一张空的句柄表,还要先搭一个地址空间的架子。此时程序还没开始执行,但系统已经开始为它记账了。

第三步最容易被误解。加载器不是把整个 exe 文件读进内存,而是按页映射:代码段映射成可执行但只读,已初始化的全局数据映射成可读写,未初始化的全局数据先占位、真正访问时才给零页。文件在磁盘上,内存里看到的是同一份内容的映射,多个进程运行同一个程序时,代码页还能共享。

第四步,程序依赖的 DLL 被逐个加载。现代程序很少只靠自己,运行库、系统库、第三方库都要进来。每加载一个,导入表里的函数地址就被填上。这一步失败,常见的表现是“缺少 xxx.dll”,进程会在进入 main 之前就退出。

第五步,主线程创建,入口不是直接指向你的 main,而是先经过运行库的启动代码:初始化堆、初始化全局对象、准备环境,最后才调用 main。所以你在 main 里看到的世界,已经是别人帮你铺好的。

Linux 的路径不一样,但阶段是对应的。shell 先 fork 出一个子进程,这时候子进程几乎是父进程的复制品;然后子进程调用 execve,把地址空间整个换掉,加载 ELF 文件,动态链接器再把依赖装进来。两步分开是有原因的,后面会讲。

看一段能实际跑的代码,确认进程里确实有这些区域:

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int g_inited = 42;
int g_zero;

int main(void) {
    int local = 7;
    int *heap = (int*)malloc(sizeof(int));
    *heap = 99;

    printf("pid=%lu\n", (unsigned long)GetCurrentProcessId());
    printf("code=%p\n", (void*)main);
    printf("data=%p\n", (void*)&g_inited);
    printf("bss=%p\n", (void*)&g_zero);
    printf("heap=%p\n", (void*)heap);
    printf("stack=%p\n", (void*)&local);

    free(heap);
    return 0;
}

本机用 gcc 16.2 编译运行,一次输出如下:

pid=45480
code=00007ff75ff614d0
data=00007ff75ff69000
bss=00007ff75ff6e020
heap=000001ead86e2710
stack=000000c8ec3ffd04

这些地址每次运行都会变,因为地址空间布局随机化(ASLR)会故意把基址挪开。但相对关系很稳定:代码和数据在同一个较高的区间,堆在另一块,栈在更低或更高的独立区间。你不需要背具体数值,只要知道它们不是一锅粥,加载器给每一类内容安排了不同的位置和权限。

进程里装的是什么

把地址空间竖着切开,大致是下面几层。注意这里的“层”不是权限层,只是内存里不同用途的区域。

代码段编译后的机器指令,只读可执行。多个进程运行同一个程序时可以共享同一份物理页。
数据段与 BSS已初始化的全局变量有初值;未初始化的先占地址,第一次访问时才真正映射零页。
堆程序运行时向分配器要的内存。分配器再向系统要页,要到的页不一定马上还回去。
栈每个线程一份,存函数调用、局部变量和返回地址。递归太深会把它撑爆。
共享库运行库和第三方 DLL 映射进来的区域,代码可共享,数据各自一份。
内核对象句柄表、进程对象、线程对象。它们不在用户地址空间里,但每个进程都有一份账。

这里最容易出问题的是句柄。进程打开一个文件、一个 Socket、一个注册表键,内核都会登记一个句柄。程序退出时,系统会回收整张表;但只要进程还活着,没关的句柄就一直占着。日志里常见的“句柄数持续上涨”,本质是代码在某条分支上提前返回,把关闭动作跳过了。它不会立刻报错,等到撞上系统上限,才会以“打开文件失败”这种看似无关的方式爆出来。

另一个常见的误解是“进程结束,线程一定结束”。反过来才成立:一个进程至少要有一条线程才能执行;主线程退出后,如果还有后台线程在跑,进程通常不会立刻消失。很多桌面程序“点了关闭窗口但任务管理器里还有残留”,就是消息循环结束了,工作线程还在等网络或写文件。

两种出生方式:fork 加 exec,和一步创建

Unix 系和 Windows 的进程创建模型不一样,理解差异能解释很多“为什么这边的代码到那边跑不通”。

Unix:先复制,再换装

父进程调用 fork,得到一个几乎一模一样的子进程;子进程再调用 execve,把自己的地址空间替换成目标程序。中间那一小段窗口,是 shell 做重定向、改环境变量、切换用户的机会。

好处是灵活:文件描述符、权限、工作目录都能在换装前安排好。代价是复制本身有开销,现代系统用写时复制(COW)把大部分复制推迟到真正写入时,但页表仍然要复制。

Windows:一步到位

CreateProcess 直接把可执行文件、命令行、环境变量、继承的句柄一起传进去,内核创建新进程并加载镜像。没有“先复制当前进程”这个阶段。

好处是语义清晰、参数显式。代价是想做“先改环境再启动”这类操作时,得在创建参数里准备好,不能像 Unix 那样先 fork 再慢慢改。

fork 的写时复制经常被说成“几乎免费”,这话只对了一半。物理页可以共享,页表不能共享;进程越大,页表越多,fork 的固定成本越高。更麻烦的是多线程进程 fork:子进程只保留调用 fork 的那个线程,其他线程在子进程里凭空消失,如果它们当时正持有锁,子进程就可能永远等在一把不存在的锁上。所以多线程程序里启动外部命令,优先用 posix_spawn 这类封装,而不是自己 fork 再 exec。

进程怎么结束:退出码、僵尸与孤儿

进程结束有几条路,每条的清理程度不一样。

正常返回 main 或调用 exit,会走运行库的清理:刷新缓冲区、执行注册的退出函数、关闭标准流,然后交给内核回收地址空间和句柄。退出码是一个整数,约定 0 表示成功,非 0 表示失败。这个约定只是约定,程序完全可以返回 0 但业务已经失败,所以自动化脚本不能只看退出码。

调用 abort 或触发未处理异常,属于异常终止:不保证刷新缓冲区,可能留下 core 文件或崩溃转储。Windows 上 TerminateProcess 是强制结束,效果类似直接拔电源,目标进程没有机会执行任何清理代码。用强杀去停数据库或写文件的程序,是数据损坏的常见来源。

Unix 上还有一种状态叫僵尸进程:子进程已经退出,但父进程还没调用 wait 取走退出状态,内核就保留一条表项,等父进程来收尸。僵尸不占内存,也不占 CPU,但占 PID 和进程表项。父进程如果长期不 wait,僵尸会越积越多,最后新进程创建失败。孤儿进程则是父进程先退出,子进程被 init 或 systemd 收养,通常能正常继续运行。

Windows 没有同名的僵尸状态,但进程对象的生命周期由引用计数管理:即使进程已经退出,只要还有别的进程持有它的句柄,对象就不会立刻销毁。另一个坑是 CloseHandle 只是关掉你手里的引用,不等于杀死进程;想结束进程得调用专门的终止接口。

现象对照表

现象真实原因第一步查什么
任务管理器里同一个程序出现很多条目程序采用多进程架构,或启动器又拉起了子进程打开“命令行”和“父进程”列,看它们是不是同一个父进程的分身
程序还没输出第一行,就占了几百 MB加载器映射了 DLL、预留了地址空间,运行时也在初始化区分“提交大小”和“工作集”,不要只看一个内存数字
进程已经退出,PID 还在列表里Unix 僵尸:父进程没有 wait 回收看状态是否为 defunct,再查父进程为什么不回收
发了终止信号,进程仍然在信号被忽略、卡在不可中断等待,或容器里的 1 号进程不转发信号看进程状态,检查信号处理函数和容器启动命令
窗口关了,进程还没退界面线程结束,但后台线程还在跑看线程列表和阻塞位置,确认退出逻辑是否真的通知了所有线程
同一程序在两台机器上内存差很多地址空间预留、DLL 版本、ASLR、缓存状态不同比较私有工作集和提交大小,而不是任务管理器默认那一列
句柄数一直涨,最后打开文件失败某条分支漏关文件或 Socket,句柄表泄漏用 Process Explorer 或 lsof 看句柄类型和数量趋势
强杀进程后配置文件变成空文件终止时没走缓冲区刷新,写到一半被切断改用正常退出信号,写入采用临时文件加原子替换

边界与代价

进程提供的隔离是实实在在的:一个进程崩溃,默认不会直接把另一个进程带走;一个进程的野指针,也改不了另一个进程的内存。这份隔离不是免费的。创建进程要建地址空间、加载镜像、填句柄表,成本远高于创建一个线程;进程间通信要么走内核复制,要么走共享内存加同步,前者有拷贝开销,后者有并发风险。

“多进程一定比多线程稳定”是个过度简化。进程边界挡得住野指针,挡不住共享资源:两个进程同时写同一个文件、抢同一把数据库锁、共用同一个下游服务,该出错还是出错。反过来,多线程共享地址空间,通信便宜,但一个线程踩坏内存,整个进程一起完蛋。选哪种,要看你更怕“内存被踩”还是更怕“通信和生命周期管理复杂”。

容器常被当成“轻量虚拟机”,其实它仍然是进程,只是多了一层命名空间和资源限制。它共享宿主机的内核,所以内核一崩,容器一起受影响;它也受宿主机 PID、句柄、内存上限的约束。把容器当安全边界用,需要额外的隔离手段,不能只靠“它在容器里”。

还有一个现实限制:PID 和句柄都是有限资源。长期运行的服务如果有进程或句柄泄漏,最终一定会在某个上限上撞墙。监控里只盯 CPU 和内存不够,进程数、线程数、句柄数都该有趋势图。

当天能自己验证的练习

  1. 用 Python 打印当前进程号,再用 subprocess 启动一个子进程打印它自己的进程号和父进程号,确认父子关系。这段在本机可以直接跑。
  2. 把上面的 C 程序编译运行两次,对比 code、heap、stack 的地址,观察 ASLR 带来的变化;再去掉随机化选项重新编译,看看差异。
  3. 在任务管理器里打开“命令行”和“父进程”列,找一个多进程程序,画出它的父子关系,确认哪个是启动器、哪些是真正干活的。
  4. 在 Linux 上写一个 fork 后不 wait 的程序,用 ps 观察 defunct 状态,再补上 wait 看它消失。本机没有 Linux 环境,这一条未在本机实测。
  5. 用 subprocess.run 启动一个故意返回 3 的程序,检查返回码;再把返回码改成 0 但让它输出错误信息,体会“退出码不等于业务结果”。

小结与下一篇

程序是磁盘上的文件,进程是加载之后的运行实例。它由地址空间、内核记账和至少一条线程组成;创建要走加载、映射、依赖、启动这几步;结束有正常退出和强制终止两条路,清理程度完全不同。僵尸、孤儿、句柄泄漏这些现象,都是这套生命周期里的某个环节没被正确处理。

下一篇讲线程、时间片与调度。进程提供了容器,真正让 CPU 忙起来的是线程;单核上“同时跑十个任务”是怎么装出来的,切换一次到底花了什么,这些问题会直接决定你线程池开多大、为什么会莫名其妙地卡顿。