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

Python的秘密基地--[章节7] Python 并发与多线程编程

news 2025/6/28 2:08:09

第7章：Python 并发与多线程编程

随着计算机硬件的发展，多核处理器已经成为主流。为了更好地利用多核资源，提高程序的运行效率，Python 提供了并发（Concurrency）和并行（Parallelism）编程的工具。本章将深入探讨 Python 中的 线程（Threading）、进程（Multiprocessing） 和 异步编程（Asyncio）。

7.1 并发与并行的区别

并发（Concurrency）：多个任务交替执行，可能在单核 CPU 上完成，主要关注任务的切换。
并行（Parallelism）：多个任务同时执行，必须依赖多核 CPU，多个任务真正“同时”运行。

简单理解：

并发 → 多个任务在同一时间段内“轮流”执行。
并行 → 多个任务在同一时刻“同时”执行。

7.2 多线程（Threading）

7.2.1 什么是线程？

线程（Thread） 是操作系统能够进行调度的最小单元。
Python 提供了 threading 模块来实现多线程。
注意：由于 GIL（全局解释器锁） 的存在，Python 的多线程无法真正实现并行计算，适合 I/O 密集型任务。

7.2.2 使用 `threading` 模块

示例：创建多线程

import threading
import timedef task(name):print(f"线程 {name} 开始")time.sleep(2)print(f"线程 {name} 结束")# 创建线程
thread1 = threading.Thread(target=task, args=("线程1",))
thread2 = threading.Thread(target=task, args=("线程2",))# 启动线程
thread1.start()
thread2.start()# 等待线程结束
thread1.join()
thread2.join()print("所有线程已完成")

输出：

线程 线程1 开始
线程 线程2 开始
线程 线程1 结束
线程 线程2 结束
所有线程已完成

7.2.3 线程锁（Lock）

多个线程同时访问共享资源时，可能会导致 数据竞争（Race Condition）。为了解决这个问题，可以使用 线程锁（Lock）。

import threadinglock = threading.Lock()
counter = 0def increment():global counterwith lock:  # 上锁temp = countertemp += 1counter = tempthreads = []
for i in range(5):t = threading.Thread(target=increment)threads.append(t)t.start()for t in threads:t.join()print(f"最终计数器值: {counter}")

7.3 多进程（Multiprocessing）

7.3.1 什么是进程？

进程（Process） 是操作系统资源分配的基本单位。
Python 的 multiprocessing 模块支持真正的 并行计算，每个进程都有自己的 Python 解释器，不受 GIL 的限制。
适合 CPU 密集型任务。

7.3.2 使用 `multiprocessing` 模块

示例：创建多进程

import multiprocessing
import timedef task(name):print(f"进程 {name} 开始")time.sleep(2)print(f"进程 {name} 结束")if __name__ == "__main__":process1 = multiprocessing.Process(target=task, args=("进程1",))process2 = multiprocessing.Process(target=task, args=("进程2",))process1.start()process2.start()process1.join()process2.join()print("所有进程已完成")

7.3.3 进程池（Pool）

当需要大量进程时，可以使用 进程池（Pool） 管理。

from multiprocessing import Pooldef square(n):return n * nif __name__ == "__main__":with Pool(4) as pool:results = pool.map(square, [1, 2, 3, 4, 5])print(results)  # [1, 4, 9, 16, 25]

7.4 异步编程（Asyncio）

7.4.1 什么是异步编程？

异步编程是一种 非阻塞 的编程方式。
使用 async 和 await 关键字。
适合 I/O 密集型任务，例如网络请求、数据库访问等。

7.4.2 异步函数

示例：异步任务

import asyncioasync def task(name):print(f"任务 {name} 开始")await asyncio.sleep(2)  # 异步等待print(f"任务 {name} 结束")async def main():await asyncio.gather(task("任务1"),task("任务2"))asyncio.run(main())

输出：

任务 任务1 开始
任务 任务2 开始
任务 任务1 结束
任务 任务2 结束

7.4.3 异步与协程

async：定义异步函数。
await：在异步函数内部暂停执行，等待某个异步任务完成。

7.5 并发工具

7.5.1 队列（Queue）

Python 提供了 queue.Queue 和 multiprocessing.Queue 来实现线程间或进程间通信。

import queue
import threadingq = queue.Queue()def producer():for i in range(5):q.put(i)print(f"生产者放入: {i}")def consumer():while not q.empty():item = q.get()print(f"消费者取出: {item}")thread1 = threading.Thread(target=producer)
thread2 = threading.Thread(target=consumer)thread1.start()
thread1.join()thread2.start()
thread2.join()

7.6 小结

线程（Threading）

适合 I/O 密集型任务。
受限于 GIL，无法实现真正的并行。

进程（Multiprocessing）

适合 CPU 密集型任务。
每个进程都有独立的内存空间。

异步编程（Asyncio）

适合 I/O 密集型任务。
使用 async 和 await 关键字实现。

7.7 实战项目：爬虫示例

使用多线程进行网页爬取

import threading
import requestsdef fetch_url(url):response = requests.get(url)print(f"{url}: {response.status_code}")urls = ["https://www.example.com", "https://www.python.org"]threads = []
for url in urls:t = threading.Thread(target=fetch_url, args=(url,))threads.append(t)t.start()for t in threads:t.join()