当前位置：首页 > news >正文

深入理解进程、线程与协程

news 2025/10/23 9:23:50

引言

在现代计算机编程中，进程（Process）、线程（Thread）和协程（Coroutine）是三个核心的并发执行概念。理解它们之间的区别和联系，对于编写高效的并发程序至关重要。

一、进程（Process）

什么是进程？

进程是操作系统进行资源分配和调度的基本单位，是程序在计算机上的一次执行活动。当你双击打开一个应用程序时，操作系统就会创建一个进程。

进程的特点

独立的内存空间：每个进程都拥有独立的地址空间，包括代码段、数据段、堆栈等
资源隔离：进程间互不干扰，一个进程崩溃不会影响其他进程
创建开销大：创建进程需要分配独立的内存空间，开销较大
通信复杂：进程间通信（IPC）需要特殊机制，如管道、消息队列、共享内存等

进程示意图

┌─────────────────────────────────────────┐
│          操作系统（OS）                  │
├─────────────┬─────────────┬─────────────┤
│  进程 A     │  进程 B      │  进程 C     │
│ ┌─────────┐ │ ┌─────────┐ │ ┌─────────┐ │
│ │代码段    │ │ │代码段    │ │ │代码段    │ │
│ │数据段    │ │ │数据段    │ │ │数据段    │ │
│ │堆       │ │ │堆       │ │ │堆       │ │
│ │栈       │ │ │栈       │ │ │栈       │ │
│ └─────────┘ │ └─────────┘ │ └─────────┘ │
└─────────────┴─────────────┴─────────────┘独立内存       独立内存       独立内存

Python 进程示例

import multiprocessing
import osdef worker(name):print(f"进程 {name} 启动，PID: {os.getpid()}")if __name__ == '__main__':processes = []for i in range(3):p = multiprocessing.Process(target=worker, args=(f'Worker-{i}',))processes.append(p)p.start()for p in processes:p.join()

二、线程（Thread）

什么是线程？

线程是进程中的一个执行单元，是CPU调度的基本单位。一个进程可以包含多个线程，它们共享进程的资源。

线程的特点

共享内存：同一进程内的线程共享进程的内存空间和资源
轻量级：创建和切换开销比进程小得多
通信简单：线程间可以直接访问共享变量
同步问题：需要处理竞态条件、死锁等并发问题

线程示意图

┌────────────────────────────────────────┐
│             进程                       │
│  ┌──────────────────────────────────┐  │
│  │      共享内存空间                 │  │
│  │  ┌─────────┐  ┌─────────┐        │  │
│  │  │代码段    │  │数据段   │        │  │
│  │  └─────────┘  └─────────┘        │  │
│  └──────────────────────────────────┘  │
│                                        │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐ │
│  │线程 1    │  │线程 2   │  │线程 3   │ │
│  │栈+寄存器 │  │栈+寄存器 │ │栈+寄存器 │ │
│  └─────────┘  └─────────┘  └─────────┘ │
└────────────────────────────────────────┘

Python 线程示例

import threading
import timedef worker(name):print(f"线程 {name} 开始执行")time.sleep(2)print(f"线程 {name} 执行完毕")threads = []
for i in range(3):t = threading.Thread(target=worker, args=(f'Thread-{i}',))threads.append(t)t.start()for t in threads:t.join()

三、协程（Coroutine）

什么是协程？

协程是一种用户态的轻量级线程，由程序自己控制调度，而不是由操作系统内核调度。协程可以在执行过程中暂停，并在稍后恢复执行。

协程的特点

超轻量级：创建成本极低，可以创建成千上万个协程
用户态调度：不需要线程上下文切换，没有内核态和用户态的切换开销
协作式调度：由程序员控制何时暂停和恢复
适合 I/O 密集型：特别适合处理大量的网络请求或文件操作

协程示意图

线程
│
├── 协程 1  ─┐
│           ├──> 共享线程资源
├── 协程 2  ─┤
│           ├──> 无需操作系统调度
├── 协程 3  ─┤
│           └──> 用户态切换
└── 协程 N执行流程：
协程1 ━━━━╸ 暂停↓
协程2      ━━━━╸ 暂停↓
协程3           ━━━━╸ 暂停↓
协程1               ━━━━ 恢复执行

Python 协程示例（使用 asyncio）

import asyncioasync def worker(name, delay):print(f"协程 {name} 开始执行")await asyncio.sleep(delay)print(f"协程 {name} 执行完毕")return f"{name} 完成"async def main():# 创建多个协程任务tasks = [worker("Coroutine-1", 2),worker("Coroutine-2", 1),worker("Coroutine-3", 3),]# 并发执行所有协程results = await asyncio.gather(*tasks)print(f"所有结果: {results}")# 运行协程
asyncio.run(main())

四、三者对比

对比表格

特性	进程	线程	协程
调度单位	操作系统调度	操作系统调度	用户程序调度
资源占用	大（MB级）	中（KB级）	小（字节级）
创建速度	慢	较快	很快
切换开销	大	中	小
内存共享	独立地址空间	共享进程内存	共享线程内存
通信方式	IPC（复杂）	共享内存（简单但需同步）	直接访问
适用场景	CPU密集型、需要隔离	并行计算	I/O密集型
数量限制	受系统资源限制（几十到几百）	受系统资源限制（几千）	几乎无限制（几万到几十万）

使用场景建议

使用进程的场景：

需要完全隔离的任务
CPU 密集型计算（可以利用多核 CPU）
任务之间需要独立的内存空间

使用线程的场景：

需要共享大量数据
任务之间需要频繁通信
I/O 和计算混合的场景

使用协程的场景：

大量的网络请求（如爬虫、API 服务）
高并发 I/O 操作
需要极高的并发数
WebSocket 长连接服务

五、实战案例：网络爬虫

使用多进程

import multiprocessing
import requestsdef fetch_url(url):response = requests.get(url)return len(response.content)if __name__ == '__main__':urls = ['http://example.com'] * 10with multiprocessing.Pool(4) as pool:results = pool.map(fetch_url, urls)print(f"总共下载: {sum(results)} 字节")

使用多线程

import threading
import requestsresults = []
lock = threading.Lock()def fetch_url(url):response = requests.get(url)with lock:results.append(len(response.content))urls = ['http://example.com'] * 10
threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]for t in threads:t.start()
for t in threads:t.join()print(f"总共下载: {sum(results)} 字节")

使用协程

import asyncio
import aiohttpasync def fetch_url(session, url):async with session.get(url) as response:content = await response.read()return len(content)async def main():urls = ['http://example.com'] * 10async with aiohttp.ClientSession() as session:tasks = [fetch_url(session, url) for url in urls]results = await asyncio.gather(*tasks)print(f"总共下载: {sum(results)} 字节")asyncio.run(main())