外观
03 - 进程和线程到底共享什么:地址空间、执行状态与资源归属
摘要
两个线程为什么会改到同一个对象,两个进程为什么通常互不影响?关键在于:线程各自保存执行状态,但通常共享进程的地址空间和打开资源;普通进程各自有地址空间,却仍可能访问同一外部资源。本文先建立这个模型,再解释局部变量、文件描述符和线程编号的边界,最后用 Python 示例展示对象的共享与隔离。
阅读指引
- 前置阅读:程序执行全景、Linux 日常命令。先知道进程从哪里来,以及如何查看 PID。
- 本文定位:回答资源属于谁、谁能访问、生命周期怎样关联;锁的实现与调度策略是后续文章的主题。
- 适用范围:资源表以现代 Linux 的普通 POSIX 线程为背景。POSIX 是一组操作系统接口标准,pthreads 是其中的线程接口,NPTL 是 Linux 常见的 POSIX 线程实现。Linux 底层的
clone创建接口可通过标志选择共享哪些资源,其特殊组合不代表普通进程的默认行为。 - 示例要求:Python 3.8+;Python 部分可在 Linux、macOS、Windows 运行。
/proc和ps -L只适用于相应 Linux 环境,输出需在目标系统验证。 - 事实边界:共享资源只说明多个线程能访问它。原子性要求操作不能被其他执行流观察为中间步骤,可见性涉及一个线程的修改何时能被另一个线程观察到;这两者都不能仅由“共享”推出。性能取决于运行库、内核、硬件和工作负载,切换耗时没有通用固定值。
1. 场景:变量写在函数里,为什么请求仍串数据
假设服务把当前请求的字段放进一个全局字典,每次进入函数再执行 local_context = global_context。开发者以为“变量是局部的,所以每个线程有一份”,但这个赋值只复制了对象引用,两个线程仍可能访问同一个字典。
即使把服务拆成两个进程,也不能据此认为“没有任何共享了”。两个进程还可能访问同一数据库行、同一共享内存、同一文件或同一外部缓存,照样需要协调。
这类问题的起点不是背“进程是资源单位,线程是调度单位”,而是把三件事拆开:
- 执行状态:现在执行哪条指令、函数调用到哪里。
- 资源环境:可以访问哪些内存、打开了什么文件。
- 共享协议:多个执行流怎样合法地修改同一个状态。
进程与线程的资源模型解释前两件事;语言内存模型和同步协议解释第三件事。语言内存模型规定并发读写的可见性和顺序,同步协议则约定如何使用锁、消息等机制协调访问。因此,“两个线程都能访问字典”与“两个请求能安全地修改字典”是两个问题。
2. 基础地图:一个进程可以承载多个执行流
Process,即进程,是程序执行时的一组资源与管理环境。Thread,即线程,是其中的一条执行流。现代 Linux 中每个可调度线程都有对应的内核任务;“一个进程在运行”可能是该进程的某个线程获得了 CPU。
Address Space,即地址空间,是进程可使用的虚拟地址及其映射和访问规则。虚拟地址是程序使用的地址,物理内存是机器实际提供的存储;二者通过映射关联。因此,地址空间不是“当前已经占用的所有物理内存”,也不是单独的 Java 堆。
线程要独立推进,就必须各自记录下一条指令的位置、寄存器值和函数调用状态,这些信息合称执行现场。寄存器是 CPU 保存当前计算状态的小型存储单元。线程共享地址空间,则意味着它们能通过有效地址或对象引用访问同一份数据,不需要先把数据复制到另一个进程。独立执行与共享数据可以同时成立。
图表将在阅读到此处时加载…
判断资源归属时,要分别问:谁能访问、谁正在使用、谁负责释放。线程可以共同访问一条连接,但连接的关闭责任仍应明确;“共享”并不意味着每个使用者都可以随时销毁它。
2.1 资源速查:共享、独立与易混淆边界
| 资源或状态 | 同一普通 Linux POSIX 进程的线程 | 关键解释 |
|---|---|---|
| 虚拟地址空间与内存映射 | 共享 | 一个线程映射或取消映射的区域会影响同进程其他线程 |
| 程序代码、全局变量、普通堆对象 | 共享可访问范围 | 是否发生竞争还取决于谁持有引用以及读写协议 |
| 文件描述符表 | 共享 | 一个线程关闭描述符,其他线程不能继续把该数字当成原资源 |
| 当前工作目录 | 共享 | 一个线程 chdir,可能改变其他线程相对路径的解析基准 |
| 创建文件时的 umask | 共享 | umask 是权限掩码,进程内临时修改可能影响其他线程创建文件 |
| 信号处理方式 | 共享 | Signal Disposition,指默认处理、忽略或处理函数;不是每线程独立注册 |
| 信号屏蔽集合 | 每线程独立 | Signal Mask 决定该线程暂时阻塞哪些可阻塞信号;详见下一篇 |
| 寄存器、指令位置、调用执行状态 | 每线程独立 | 切换后必须恢复,才能从自己的执行位置继续 |
| 栈的使用与栈指针 | 每线程有自己的栈 | 栈一般仍位于共享地址空间,不是访问隔离墙 |
TLS、errno | 每线程有自己的对应状态 | TLS(Thread-local Storage)是线程局部存储;errno 是常见 C 接口记录错误编号的状态。线程局部存储不自动复制它指向的对象 |
| 调度状态、原生线程标识 | 每线程有对应状态 | 某线程在等待,不代表同进程其他线程不能运行 |
| 进程环境变量 | 进程环境 | 原生代码并发修改环境有库级约束,不能当作线程局部配置 |
这张表描述常见模型,不意味着所有 Linux 任务属性都只能按“进程全共享/线程全独立”二选一。Linux 的底层创建接口可选择共享项,身份等属性也有内核和 POSIX 库协作的细节;理解应用时先从实际使用的 pthreads、语言运行时或容器模型出发。
2.2 “线程栈私有”到底私有在哪里
栈是保存函数调用信息的一块内存区域,栈指针记录当前栈的使用位置。每个线程有自己的栈区域和栈指针,用来记录函数调用、返回位置和需要存放在栈上的局部数据。这里的“私有”主要是分配与使用归属,不是不同进程那样的地址空间隔离。
在 C 等语言中,如果把栈上对象的地址交给另一个线程,并且对象生命周期仍有效,另一个线程可以通过该地址访问。函数返回后对象生命周期结束,继续使用该指针可能成为悬空访问;这不是给对象加锁就能修复的问题。
在 Java、Python 等语言中,局部变量可能只是一个引用,引用指向的对象仍可能被多个线程持有。编译器还可能优化变量存放方式,所以不能从“源代码写在函数里”推断物理位置或线程隔离。
反例:local_context = shared_context,然后修改其中的请求字段。
正例:为每个请求建立独立状态,或在确实需要共享时建立清晰的同步与所有权协议。浅拷贝只复制外层容器;里面嵌套的可变对象仍可能共享,不能无条件把浅拷贝当隔离方案。
3. 两个进程为何通常隔离,又为什么仍能共享
3.1 相同虚拟地址,不保证是同一块物理内存
普通进程各自有地址空间。内存映射通常以固定大小的页为单位管理;Page Table,即页表,记录虚拟页与实际映射及权限的关系。CPU 访问虚拟地址时,依据当前地址空间的映射完成地址转换和权限检查。
因此,两个进程中数值相同的指针,不能直接用来证明它们访问同一个对象。共享映射让多个进程访问同一底层区域;写时复制则允许适用的私有页面先共享底层存储,在写入时再分离。底层物理页暂时相同,不意味着普通私有变量的修改会互相传播。
text
进程 A 的虚拟地址 0x... → A 的映射与访问规则 → 相应内存
进程 B 的虚拟地址 0x... → B 的映射与访问规则 → 相应内存
两行中地址数值可以相同,资源身份仍需分别判断。这里不要求先理解全部分页细节。后续虚拟内存篇再展开页、页表、TLB,即地址转换缓存,以及缺页处理;当前先保留“虚拟地址必须结合所属进程解释”的模型。
3.2 IPC 是明确建立的跨进程通道
IPC,即 Inter-process Communication,指进程间通信。它让独立地址空间中的程序通过明确的通道交换数据或通知。管道和 socket(套接字,通信端点)通过发送、接收传递数据;共享内存则把同一底层区域映射进多个进程。
发送、接收需要处理消息边界、部分读写、超时和对端退出。下游处理较慢时,还要通过反压限制上游继续发送,避免队列无限增长。共享内存需要约定数据布局、同步、生命周期以及进程崩溃后的恢复;能共同访问内存不代表这些规则已经具备。
文件、数据库和外部缓存也是多个进程可能共同访问的资源,需要考虑一致性、事务、锁、持久化和重复请求。地址空间隔离减小普通内存互相破坏的范围,却不能消除外部资源冲突。两个进程同时扣减库存,问题仍可能是事务协议而不是线程锁。
3.3 IPC 基础速查:隔离后怎样交流
选择通道时,除了看传递什么,还要看数据边界和释放责任:
| 机制 | 适合交换什么 | 基础边界与释放责任 |
|---|---|---|
| 匿名管道 / FIFO(命名管道) | 按字节顺序传递数据;FIFO 通过名称找到管道入口 | 普通管道是字节流,不保存业务消息边界;全部写端引用关闭且缓冲数据读完后,读取才返回 EOF(流结束) |
| Unix domain socket(Unix 域套接字) | 同机端点通信;按接口可用流或消息形式 | SOCK_STREAM 是流式接口,没有消息边界;数据报等模式规则不同,端点与路径需要管理 |
| 共享内存 / 共享映射 | 多进程访问同一底层区域 | 共享不提供自动同步;数据布局、锁与异常恢复都需协议 |
| 消息队列 | 按所用 API 提交和接收消息 | 容量、消息大小、持久性与清理依实现,不能泛化为可靠业务消息系统 |
| 信号 | 通知事件或停止意图 | 标准信号不能可靠地按发生次数计数,不能代替带载荷和确认的通信协议 |
例如父进程通过管道读子进程输出,如果自己或其他后代还持有写端,管道仍可能有数据写入,所以子进程结束也不保证读者马上看到 EOF。让多个进程共享内存可能减少部分数据复制,却增加同步与故障恢复责任,不能据此断言一定更快。
接口基础依据为 Linux pipe(7)、unix(7)与 signal(7)。下一篇 创建、信号与退出解释父子关系,I/O 模型与消息读取进一步解释分段数据和等待。
4. 文件描述符:表共享不等于文件内容只存一份
File Descriptor(FD),即文件描述符,是进程访问打开资源的整数入口。描述符表记录这些整数对应的内核对象。Open File Description,即打开文件描述,是内核记录某次打开状态的对象,常包含文件偏移和状态标志。文件偏移表示下一次适用读写的位置;多个入口指向同一打开状态时,读写位置也可能互相影响。
text
线程 A / 线程 B
↓ 使用同一进程的描述符表
描述符 3 ──→ 打开文件描述 ──→ 文件等底层资源必须区分三层:数字、打开状态对象、底层资源。
- 同进程线程共享描述符表。A 关闭
3后,B 继续使用3可能得到错误,也可能遇到数字被重新分配后的另一个资源。 dup得到另一个描述符入口,但仍引用同一个打开文件描述,常共享文件偏移;不是“复制一个互不影响的打开状态”。- 对同一路径分别
open,通常创建不同打开文件描述,偏移可独立,但底层文件内容仍是共同资源。 fork后父子有各自的描述符表,但继承的对应条目仍引用同一个打开文件描述;并非“父子文件完全隔离”。
这解释了两类容易混在一起的故障:线程之间误关闭连接,属于共享表与生命周期;父子读文件互相改变偏移,属于共享打开状态。具体 inode、目录、链接和删除规则留给文件系统篇,不在这里把文件名等同于资源身份。
工程正例:明确“谁负责关闭、谁只借用、是否会跨线程或跨进程传递”。共享使用不代表所有参与者都可以关闭;连接池也不能让借用者直接销毁池维护的底层资源。
5. 执行现场、调度与标识:先认对观察对象
5.1 PID、TID 与语言线程编号
PID 是进程标识,TID 是线程标识。在现代 Linux 的普通线程组中,同一进程的线程组成一个线程组,其标识 TGID 通常是应用看到的进程 PID;每个内核线程有 TID,线程组首线程的 TID 与 TGID 相同。
| 标识 | 表达什么 | 不应怎样使用 |
|---|---|---|
| Linux PID / TGID | 当前 PID namespace 中的进程或线程组标识 | 不当作跨容器、跨时间永久唯一编号 |
| Linux TID | 当前视图中的内核线程标识 | 不与 Java 或 pthread 的编号直接比较 |
pthread_t | POSIX 线程库的线程标识类型 | 不假定等于整数形式的 Linux TID |
Python ident | Python 的线程标识 | 不当作操作系统原生编号,线程退出后可能复用 |
Python native_id | 平台提供的原生线程标识 | 必须结合平台与线程有效生命周期解释 |
| Java 线程 ID / 名称 | JVM 层线程身份信息 | 虚拟线程不与内核线程固定一一对应 |
Namespace,即命名空间,是 Linux 提供不同资源视图的机制;同一任务在不同 PID namespace 中可能显示不同编号,容器篇再详细展开。排障时记录实例、PID、启动时间和采样时刻,不只留下一个整数。
bash
# Linux / procps 示例:先替换为已核对的进程 PID,不对目标进行修改。
target_pid=12345
ps -L -p "$target_pid" -o pid,tid,stat,pcpu,comm
grep -E '^(Name|State|Tgid|Pid|PPid|Threads):' "/proc/$target_pid/status"/proc/<pid>/task/ 可查看相应线程目录;权限、进程退出和 namespace 都会影响可见结果。ps 的 CPU 百分比口径也依工具而异,不能从一次输出推算请求的精确计算时长。
5.2 上下文切换究竟切了什么
Context Switch,即上下文切换,是保存当前执行现场并恢复另一任务的过程。不同线程至少有不同寄存器与执行状态;切换到另一个地址空间时,还要处理相应地址转换环境。
同进程线程虽然共享地址空间,切换时仍要保存和恢复执行现场,因此切换并非零成本。跨进程切换也不等于每次清空全部缓存。实际成本取决于架构、地址转换标签、工作集、缓存和具体路径:地址转换标签用于区分不同地址空间的转换记录,工作集是任务在一段时间内频繁访问的数据和代码。缺少固定环境下的测量,无法给出“线程切换总比进程切换快几倍”的结论。
用户态到内核态的权限模式切换不一定改变正在运行的线程;同一线程可以进入内核,完成系统调用后继续执行。是否发生任务切换,要看等待、唤醒和调度证据。
5.3 并发、并行与等待
Concurrency,即并发,强调多个任务在一段时间内交替推进;Parallelism,即并行,强调同一时刻多个任务实际执行。单核也能并发,多核不保证某个业务有足够任务和配额实现并行。
线程在等待网络或锁时不一定占用 CPU,但仍可能占着栈、上下文、连接和业务预算。增加线程可能改善部分等待型任务的吞吐,也可能扩大排队和下游压力。容量设计不能只算 CPU 核数,需结合到达率、持有时间、队列与资源上限。
虚拟线程是语言运行时调度的执行单元,不是每创建一个虚拟线程就增加一个内核线程。Java 虚拟线程由承载它的线程执行;某些路径可能发生 pinning,即虚拟线程被固定在承载线程上。具体阻塞路径和版本条件见 JDK 21 虚拟线程。
6. 可运行实战:线程共享一个对象,子进程修改自己的副本
将以下保存为 resource_owner_demo.py,用 python3 resource_owner_demo.py 运行。Windows 用实际可用的 Python 解释器路径运行同一文件即可,不依赖 WSL。
本例使用 Lock,即互斥锁,让共享计数的修改每次只由一个线程执行;使用 Event,即事件同步对象,通知工作线程何时开始。正常完成时,主线程会先确认两个工作线程都已就绪,再放行计数循环。示例展示资源关系,不用于测量竞态出现概率或性能。
python
import json
import os
import subprocess
import sys
import threading
def main():
shared = {"count": 0}
lock = threading.Lock()
gate = threading.Event()
ready = [threading.Event(), threading.Event()]
records = []
def worker(worker_index):
local_reference = shared # 局部引用仍指向同一个对象。
with lock:
records.append({
"worker": worker_index,
"pid": os.getpid(),
"native_id": threading.get_native_id(),
})
ready[worker_index].set()
if not gate.wait(timeout=3): # 有界等待,不依赖 sleep 碰运气同步。
return
for step_index in range(3):
with lock:
local_reference["count"] += 1
threads = [
threading.Thread(target=worker, args=(worker_index,))
for worker_index in range(2)
]
try:
for thread in threads:
thread.start()
for event in ready:
if not event.wait(timeout=2):
raise RuntimeError("工作线程未在期限内就绪")
finally:
gate.set() # 即使父线程报错,也允许已启动的工作线程结束。
for thread in threads:
if thread.ident is not None:
thread.join(timeout=4)
if thread.is_alive():
raise RuntimeError("工作线程未在期限内退出")
assert shared["count"] == 6
assert len(records) == 2
assert all(record["pid"] == os.getpid() for record in records)
assert len({record["native_id"] for record in records}) == 2
print("threads:", json.dumps(sorted(records, key=lambda item: item["worker"])))
# 通过参数序列化数据;子进程创建自己的字典,不传递活对象引用。
child_code = """
import json, os, sys
state = json.loads(sys.argv[1])
state["count"] += 100
print(json.dumps({"pid": os.getpid(), "state": state}))
"""
result = subprocess.run(
[sys.executable, "-c", child_code, json.dumps(shared)],
capture_output=True, text=True, check=True, timeout=5,
)
child_result = json.loads(result.stdout)
assert child_result["pid"] != os.getpid()
assert child_result["state"]["count"] == 106
assert shared["count"] == 6
print("child:", json.dumps(child_result))
print("parent count:", shared["count"])
if __name__ == "__main__":
main()预期输出:在工作线程按期就绪、继续执行并通过断言的正常路径中,两个线程 PID 相同、原生线程 ID 不同;子进程 PID 不同,其计数为 106,父进程计数仍为 6。具体编号随运行变化。
两个线程各执行三次加一,并通过锁访问同一个字典,所以父进程得到 6。父进程随后把字典编码为 JSON 文本,子进程再解码出自己的字典,因此子进程加上 100 后得到 106,不会修改父进程中的对象。序列化传递的是数据内容,不是可直接访问父进程对象的引用。
这里显式把数据序列化后传给子进程,证明的是“子进程重建了自己的对象”。它没有测量 fork 的写时复制,也不说明共享内存不可能存在。subprocess.run 的超时路径会终止并等待直接子进程;初始创建过程不一定能在所有平台立即被超时打断。
6.1 为什么不靠 GIL 或随机丢失的计数展示原理
GIL,即 Global Interpreter Lock,是部分 Python 实现限制同时执行解释器代码的机制。常规启用 GIL 的 CPython、可选 free-threaded 构建以及其他解释器的条件并不相同;原生扩展和 I/O 也有自己的执行路径。
所以“在我的 Python 上没有丢计数”不能证明复合操作在所有语言里原子,也不能推导 Java 的可见性规则。本例使用明确的锁和事件,让断言针对资源关系,而不是依赖某次调度碰巧出现竞争。
在 Java 中,应按 JMM 与 happens-before分析读写关系;不要用“线程共享堆”跳过同步、发布和重排序条件。
7. 排障:共享资源问题怎样缩小范围
| 现象 | 首先确认的对象 | 有价值的证据 | 不足以成立的结论 |
|---|---|---|---|
| 请求字段串到其他请求 | 引用、对象生命周期与上下文传播 | 对象归属、创建点、跨线程传递路径 | 变量名叫 local,所以一定隔离 |
| 连接突然失效或报 bad file descriptor | 描述符和关闭责任 | 创建、借用、归还、关闭的时间线 | 文件名没变,所以描述符仍有效 |
| 线程数多、CPU 却不高 | 等待对象、任务持有资源 | 多次线程栈、队列和下游等待 | 所有线程都在工作,应该继续加线程 |
| 内存随线程数增长 | 栈、TLS、堆、native 分配 | 线程数量、映射和运行时内存口径 | Java 堆没涨,所以没用更多内存 |
| 一个进程崩溃影响多个请求 | 共享地址空间与故障域 | 崩溃现场、原生扩展、共享资源 | 每个请求独立线程,所以故障互不影响 |
进一步读 JVM 运行时数据区与内存布局,区分规范区域、对象存放与进程内存口径;读 JVM 故障排查把 OS 线程、运行时栈和实例时间线对齐。
ThreadLocal 是线程局部引用存储,不是请求作用域的自动清理器。长寿命池线程复用时,旧状态可能继续被新任务看见,具体保留链与清理协议见 ThreadLocal 内存泄漏与上下文污染。
8. 容易踩的坑与工程取舍
8.1 反例:线程共享内存,所以不需要通信协议
共享只说明可访问范围,不保证读写顺序,也不保证业务约束始终成立,例如多个字段必须一起更新。用语言支持的锁等同步原语约定何时允许其他线程读取、何时可以修改;也可以用不可变对象和消息传递减少共同修改的状态。
8.2 反例:换多进程就解决所有竞争
多进程常能增强普通地址空间的隔离,但共享文件、数据库和外部服务仍会冲突。正例:先列出共享对象,再按对象选择事务、锁或消息协议,不按“线程/进程”标签直接选方案。
8.3 反例:线程越多,吞吐越高
线程增加会带来执行状态、栈和调度等成本,等待期间还可能占连接与业务配额。正例:在明确预算下测量吞吐、长尾、队列与下游压力,限制进入系统的工作量。
8.4 反例:线程局部对象不用清理
TLS 只改变访问位置,不改变它指向资源的关闭协议。正例:按请求或任务生命周期释放资源;是否为池线程、是否会复用要写进协议。
8.5 隔离与共享不是谁绝对更好的比赛
同进程通信通常更直接,但共享地址空间也扩大内存破坏的影响范围。跨进程可增强隔离,却要设计通信、序列化、背压和故障恢复。选择看工作负载、故障域、部署和资源预算,不用未经测量的“某种模型快十倍”替代工程分析。
9. 名词解释与延伸阅读
| 名词 | 回查解释 |
|---|---|
| Process / Thread | 执行的资源环境 / 其中的一条执行流 |
| Address Space / Page Table | 虚拟地址及映射规则 / 记录地址映射与权限的结构 |
| TLS / errno | 线程局部存储 / 常见 C 接口记录错误信息的线程相关状态 |
| FD / Open File Description | 打开资源的整数入口 / 内核中的一次打开状态对象 |
| PID / TGID / TID | 进程标识 / Linux 线程组标识 / 原生线程标识,均有视图与生命周期边界 |
| NPTL / pthreads | Linux 常见 POSIX 线程实现 / POSIX 线程接口体系 |
| IPC / Context Switch | 跨进程通信 / 执行现场的保存与恢复 |
| Concurrency / Parallelism | 多任务交替推进 / 多任务在同一时刻执行 |
| GIL | 特定解释器的执行协调机制,不是通用的线程安全证明 |
- 自然后续:进程创建、信号与退出,把资源归属落实到创建、终止和回收。
- 执行与内存分支:调度与切换解释执行机会,虚拟地址与分页解释地址映射、访问保护和驻留口径。
- 语言层对照:Java 线程生命周期与中断,区分 JVM 状态、中断协议和 OS 线程状态。
- 规则依据:Linux man-pages 的
pthreads(7)、gettid(2)、open(2)、dup(2)、fork(2);Python 标准库的threading、subprocess文档。pthreads(7)中旧 LinuxThreads 的历史限制不可直接套用到现代 NPTL。
10. 一句话总结与三个要点
线程拥有各自的执行现场,但通常共享进程资源;隔离和同步必须分别设计。
- 用资源表判断共享,而不是用“局部变量”“线程私有栈”等词直接推导对象隔离。
- 地址、描述符和线程编号都必须结合所属对象与生命周期解释,整数相同不代表身份相同。
- OS 资源模型解释访问范围,语言同步协议解释合法读写;线程数与性能必须在真实预算中验证。