引言：理解并发编程

在现代计算中，并发编程是提高程序性能的关键技术。Python提供了两种主要的并发实现方式：进程(Process)和线程(Thread)。尽管它们都用于实现并发执行，但它们在资源分配、内存使用和执行方式上存在根本区别。

进程与线程核心区别

Python多线程编程

Python通过threading模块提供线程支持。由于GIL（全局解释器锁）的存在，Python线程在CPU密集型任务中无法实现真正的并行，但在I/O密集型任务中非常有效。

线程创建示例

import threading
import time

# 线程执行函数
def print_numbers(thread_name, delay):
    for i in range(1, 6):
        time.sleep(delay)
        print(f"{thread_name}: {i}")

# 创建线程
thread1 = threading.Thread(target=print_numbers, args=("Thread-1", 0.5))
thread2 = threading.Thread(target=print_numbers, args=("Thread-2", 0.7))

# 启动线程
thread1.start()
thread2.start()

# 等待线程结束
thread1.join()
thread2.join()

print("所有线程执行完成")

线程同步机制

当多个线程访问共享资源时，需要使用同步机制防止数据竞争：

import threading

# 共享资源
counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # 使用锁保证原子操作
            counter += 1

# 创建多个线程
threads = []
for i in range(5):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

# 等待所有线程完成
for t in threads:
    t.join()

print(f"最终计数器值: {counter}")  # 正确输出500000

Python多进程编程

Python通过multiprocessing模块提供进程支持。每个进程有独立的Python解释器和内存空间，可以绕过GIL限制，充分利用多核CPU。

进程创建示例

import multiprocessing
import time

def worker(name, delay):
    print(f"进程 {name} 开始运行")
    time.sleep(delay)
    print(f"进程 {name} 完成")

if __name__ == "__main__":
    # 创建进程
    p1 = multiprocessing.Process(target=worker, args=("Process-1", 2))
    p2 = multiprocessing.Process(target=worker, args=("Process-2", 3))
    
    # 启动进程
    p1.start()
    p2.start()
    
    # 等待进程结束
    p1.join()
    p2.join()
    
    print("所有进程执行完成")

进程间通信(IPC)

进程间通信需要使用特殊机制，如Queue、Pipe等：

import multiprocessing

def square(numbers, q):
    for n in numbers:
        q.put(n * n)  # 将结果放入队列

if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 5]
    q = multiprocessing.Queue()  # 创建队列
    
    # 创建进程
    p = multiprocessing.Process(target=square, args=(numbers, q))
    p.start()
    p.join()
    
    results = []
    while not q.empty():
        results.append(q.get())
    
    print(f"计算结果: {results}")  # 输出: [1, 4, 9, 16, 25]

进程池与线程池

Python提供了concurrent.futures模块，简化并发任务的管理：

from concurrent.futures import ThreadPoolExecutor
import time

def task(n):
    time.sleep(1)
    return n * n

with ThreadPoolExecutor(max_workers=3) as executor:
    # 提交任务
    futures = [executor.submit(task, i) for i in range(5)]
    
    # 获取结果
    results = [f.result() for f in futures]
    print(results)  # 输出: [0, 1, 4, 9, 16]

from concurrent.futures import ProcessPoolExecutor
import time

def task(n):
    time.sleep(1)
    return n * n

if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=3) as executor:
        futures = [executor.submit(task, i) for i in range(5)]
        results = [f.result() for f in futures]
        print(results)  # 输出: [0, 1, 4, 9, 16]

性能对比：何时使用进程或线程？

总结：进程与线程的选择指南