进程和线程 - 技术栈

进程和线程的概念

进程和线程是操作系统中非常重要的两个概念，它们是程序执行的两种基本单位。

1. 基本定义

进程（Process）

进程是程序的一次执行过程，是系统进行资源分配和调度的基本单位。

每个进程都有独立的内存空间、文件描述符、环境变量等资源
进程之间相互隔离，一个进程崩溃不会影响其他进程
创建进程的开销较大

线程（Thread）

线程是进程内的一个执行单元，是CPU调度的基本单位。

同一个进程内的多个线程共享进程的资源（内存、文件等）
线程之间可以方便地通信
创建线程的开销较小

2. 直观类比

餐厅类比

进程 = 整个餐厅：有独立的厨房、餐具、服务员、用餐区
线程 = 餐厅里的服务员：多个服务员共享餐厅资源，各自服务不同的顾客

工厂类比

进程 = 一个独立的工厂：有自己的厂房、机器、工人、原材料
线程 = 工厂里的工人：共享工厂资源，可以同时做不同的工作

软件应用类比

复制代码

进程：微信App（独立运行，有自己的内存空间）
├── 线程1：接收消息
├── 线程2：发送消息
├── 线程3：更新UI界面
└── 线程4：处理语音通话

进程：浏览器（独立运行）
├── 线程1：渲染页面
├── 线程2：下载文件
└── 线程3：处理用户点击

3. 核心区别对比表

特征	进程	线程
资源占用	独立内存空间，占用大	共享进程内存，占用小
创建速度	慢（需要复制资源）	快（只需创建栈和寄存器）
切换速度	慢（需要切换地址空间）	快（共享地址空间）
通信方式	复杂（IPC：管道、队列、共享内存）	简单（直接读写共享变量）
同步机制	复杂（信号量、文件锁等）	需要锁、信号量保护共享数据
独立性	强（崩溃不影响其他进程）	弱（一个线程崩溃可能导致整个进程崩溃）
安全性	高（地址空间隔离）	低（共享内存，容易相互影响）
系统开销	大	小

4. 代码示例对比

多进程示例（Python）

python 复制代码

from multiprocessing import Process
import os

def worker(name):
    print(f"进程 {name} - PID: {os.getpid()}")
    # 每个进程有独立的内存空间
    local_var = 100  # 这个变量在每个进程中独立

if __name__ == "__main__":
    processes = []
    for i in range(3):
        p = Process(target=worker, args=(f"进程{i}",))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

多线程示例（Python）

python 复制代码

from threading import Thread
import os
import threading

# 线程间共享全局变量
shared_var = 0

def worker(name):
    global shared_var
    print(f"线程 {name} - PID: {os.getpid()} (线程ID: {threading.current_thread().ident})")
    shared_var += 1  # 多个线程修改同一个变量

if __name__ == "__main__":
    threads = []
    for i in range(3):
        t = Thread(target=worker, args=(f"线程{i}",))
        threads.append(t)
        t.start()
    
    for t in threads:
        t.join()
    
    print(f"最终 shared_var = {shared_var}")  # 可能是3（但需要锁保护）

5. 内存布局对比

进程内存布局

复制代码

进程1                         进程2
┌─────────────────┐          ┌─────────────────┐
│   代码段(Code)   │          │   代码段(Code)   │
├─────────────────┤          ├─────────────────┤
│   数据段(Data)   │          │   数据段(Data)   │
├─────────────────┤          ├─────────────────┤
│     堆(Heap)     │          │     堆(Heap)     │
├─────────────────┤          ├─────────────────┤
│     栈(Stack)    │          │     栈(Stack)    │
├─────────────────┤          ├─────────────────┤
│   环境变量等     │          │   环境变量等     │
└─────────────────┘          └─────────────────┘
     独立隔离                        独立隔离

线程内存布局（同一进程内）

复制代码

进程
┌─────────────────────────────────────┐
│         代码段(共享)                 │
├─────────────────────────────────────┤
│         数据段(共享)                 │
├─────────────────────────────────────┤
│          堆(共享)                    │
├─────────────┬─────────────┬─────────┤
│   线程1栈    │   线程2栈    │ 线程3栈  │
├─────────────┼─────────────┼─────────┤
│   线程局部存储(TLS)                  │
└─────────────────────────────────────┘

6. 实际应用场景

适合使用多进程的场景

python 复制代码

# 1. CPU密集型任务（计算密集型）
def calculate_primes():
    """计算大量素数 - CPU密集"""
    primes = []
    for i in range(2, 10000000):
        # 复杂的计算逻辑
        pass

# 2. 需要高稳定性的场景
# 一个进程崩溃不影响其他进程

# 3. 需要隔离资源的场景
# 不同用户的数据处理

适合使用多线程的场景

python 复制代码

import threading
import time
import requests

# 1. I/O密集型任务（网络请求、文件读写）
def download_file(url):
    """下载文件 - I/O密集"""
    response = requests.get(url)  # 等待网络响应
    return response.content

# 2. 需要共享大量数据的场景
shared_data = []
lock = threading.Lock()

def update_data():
    with lock:
        shared_data.append(time.time())

# 3. GUI程序（保持界面响应）
def background_task():
    while True:
        time.sleep(1)
        # 后台工作，不阻塞界面

7. 进程间通信（IPC）方式

python 复制代码

# 1. 队列（Queue）
from multiprocessing import Queue, Process

def producer(q):
    q.put("数据")

def consumer(q):
    data = q.get()

# 2. 管道（Pipe）
from multiprocessing import Pipe

parent_conn, child_conn = Pipe()
parent_conn.send("消息")
msg = child_conn.recv()

# 3. 共享内存
from multiprocessing import Value, Array

counter = Value('i', 0)  # 共享整数
array = Array('i', [1, 2, 3])  # 共享数组

# 4. 文件
# 5. 套接字（Socket）

8. 线程同步机制

python 复制代码

import threading

# 1. 互斥锁（Lock）
lock = threading.Lock()
shared_counter = 0

def increment():
    global shared_counter
    for _ in range(1000):
        with lock:
            shared_counter += 1

# 2. 可重入锁（RLock）
rlock = threading.RLock()

# 3. 信号量（Semaphore）
semaphore = threading.Semaphore(3)  # 允许3个线程同时访问

# 4. 事件（Event）
event = threading.Event()
def waiter():
    event.wait()  # 等待事件
    print("继续执行")

# 5. 条件变量（Condition）
condition = threading.Condition()

9. 优缺点对比

进程的优点

✅ 稳定性高：一个进程崩溃不影响其他进程
✅ 安全性好：地址空间隔离，数据更安全
✅ 多核利用好：可以充分利用多核CPU
✅ 分布式友好：可以分布到不同机器

进程的缺点

❌ 资源占用大：每个进程都有独立的内存空间
❌ 创建慢：需要复制资源
❌ 切换慢：需要切换地址空间
❌ 通信复杂：需要IPC机制

线程的优点

✅ 轻量级：创建和销毁开销小
✅ 切换快：共享地址空间，切换成本低
✅ 通信简单：直接读写共享变量
✅ 资源利用率高：共享内存，节省资源

线程的缺点

❌ 稳定性差：一个线程崩溃可能导致整个进程崩溃
❌ 同步复杂：需要锁、信号量等机制
❌ 调试困难：并发问题难以复现和调试
❌ GIL限制（Python）：CPU密集型任务无法真正并行

10. 选择指南

python 复制代码

# 决策树
def choose_concurrency(task_type, need_isolation, need_communication):
    if task_type == "CPU密集型":
        if need_isolation:
            return "多进程"
        else:
            return "多进程（推荐）或协程"
    elif task_type == "I/O密集型":
        if need_isolation:
            return "多进程 + 协程"
        else:
            return "多线程 或 协程（推荐）"
    else:
        if need_communication == "频繁且大数据量":
            return "多线程（共享内存）"
        else:
            return "多进程（队列通信）"

# 实际例子
# 场景1：视频编码（CPU密集）
# 推荐：多进程

# 场景2：Web服务器处理请求（I/O密集）
# 推荐：多线程 或 协程

# 场景3：科学计算（CPU密集）
# 推荐：多进程

# 场景4：爬虫下载网页（I/O密集）
# 推荐：多线程 或 协程

11. Python特殊情况：GIL

python 复制代码

# Python的GIL（全局解释器锁）
# GIL导致同一时刻只有一个线程执行Python字节码

import threading
import time

# CPU密集型：多线程反而更慢
def cpu_bound():
    total = 0
    for i in range(50_000_000):
        total += i

# 多线程（CPU密集）-> 反而更慢
threads = [threading.Thread(target=cpu_bound) for _ in range(4)]
start = time.time()
for t in threads: t.start()
for t in threads: t.join()
print(f"多线程耗时: {time.time() - start}秒")  # 比单线程慢

# 使用多进程解决
from multiprocessing import Pool
with Pool(4) as pool:
    pool.map(lambda _: cpu_bound(), range(4))
print(f"多进程耗时: {time.time() - start}秒")  # 真正并行

总结

进程是资源分配的单位 ，线程是CPU调度的单位
进程之间相互独立 ，线程之间共享资源
CPU密集型任务适合多进程
I/O密集型任务适合多线程或协程
Python中由于GIL，多线程对CPU密集型任务无效
根据具体场景选择合适的并发模型