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

原创于 2025-10-22 17:38:45 发布 · 914 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

部署运行你感兴趣的模型镜像

引言

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

一、进程（Process）

什么是进程？

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

进程的特点

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

进程示意图

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

Python 进程示例

import multiprocessing
import os

def 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 time

def 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 asyncio

async 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 requests

def fetch_url(url):
    response = requests.get(url)
    return len(response.content)

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

使用多线程

import threading
import requests

results = []
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 aiohttp

async 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'] * 10
    async 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())