并发编程 #

一、多线程 #

python
import threading

def task(name):
    print(f"任务 {name} 开始")
    # 执行任务
    print(f"任务 {name} 结束")

# 创建线程
t1 = threading.Thread(target=task, args=("A",))
t2 = threading.Thread(target=task, args=("B",))

# 启动线程
t1.start()
t2.start()

# 等待线程完成
t1.join()
t2.join()

二、线程锁 #

python
import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # 加锁
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(counter)  # 1000000

三、线程池 #

python
from concurrent.futures import ThreadPoolExecutor

def task(n):
    return n ** 2

with ThreadPoolExecutor(max_workers=5) as executor:
    # 提交任务
    futures = [executor.submit(task, i) for i in range(10)]
    
    # 获取结果
    for future in futures:
        print(future.result())
    
    # 或使用map
    results = list(executor.map(task, range(10)))

四、多进程 #

python
import multiprocessing

def task(name):
    print(f"进程 {name}")

if __name__ == '__main__':
    processes = [
        multiprocessing.Process(target=task, args=(i,))
        for i in range(4)
    ]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()

五、进程池 #

python
from concurrent.futures import ProcessPoolExecutor

def task(n):
    return n ** 2

if __name__ == '__main__':
    with ProcessPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(task, range(10)))
        print(results)

六、进程间通信 #

python
import multiprocessing

def worker(queue):
    queue.put("来自子进程的消息")

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    p = multiprocessing.Process(target=worker, args=(queue,))
    p.start()
    print(queue.get())  # "来自子进程的消息"
    p.join()

七、共享内存 #

python
import multiprocessing

def worker(counter):
    with counter.get_lock():
        counter.value += 1

if __name__ == '__main__':
    counter = multiprocessing.Value('i', 0)
    
    processes = [
        multiprocessing.Process(target=worker, args=(counter,))
        for _ in range(10)
    ]
    
    for p in processes:
        p.start()
    for p in processes:
        p.join()
    
    print(counter.value)  # 10

八、总结 #

方式 适用场景 特点
多线程 IO密集型 共享内存,受GIL限制
多进程 CPU密集型 独立内存,无GIL限制
协程 IO密集型 轻量级,高并发

GIL(全局解释器锁):

  • 同一时刻只有一个线程执行Python字节码
  • 多线程不适合CPU密集型任务
  • 多进程可以绑过GIL限制
最后更新:2026-03-16