Python 基础入门 Day33 —— 并发与多线程编程

共计 2335 个字符，预计需要花费 6 分钟才能阅读完成。

欢迎来到 Python 基础入门 Day33！今天我们将探讨 并发编程 ，重点讲解 Python 中的 多线程（threading） 和 多进程（multiprocessing），并介绍 异步编程（asyncio） 的基本概念。

目录

1. 什么是并发编程？
2. 使用 threading 进行多线程编程
3. 使用 multiprocessing 进行多进程编程
4. 异步编程入门 (asyncio)
5. 小结与练习

1. 什么是并发编程？

并发 是指在同一时间段内执行多个任务，而 并行 是指在多个 CPU 核心上同时执行多个任务。Python 提供了三种主要的并发方式：

2. threading —— 多线程编程

2.1 创建线程

import threading
import time

def worker():
    print(f"线程 {threading.current_thread().name} 开始工作")
    time.sleep(2)
    print(f"线程 {threading.current_thread().name} 完成工作")

# 创建两个线程
thread1 = threading.Thread(target=worker, name="Thread-1")
thread2 = threading.Thread(target=worker, name="Thread-2")

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

# 等待线程完成
thread1.join()
thread2.join()

print("所有线程完成")

2.2 使用 ThreadPoolExecutor

Python 提供 concurrent.futures.ThreadPoolExecutor 让多线程管理更简单：

from concurrent.futures import ThreadPoolExecutor

def task(name):
    print(f"{name} 任务执行中")
    time.sleep(1)
    return f"{name} 任务完成"

with ThreadPoolExecutor(max_workers=3) as executor:
    results = executor.map(task, ["任务 1", "任务 2", "任务 3"])

print(list(results))

3. multiprocessing —— 多进程编程

3.1 创建进程

import multiprocessing
import os

def process_task():
    print(f"进程 {os.getpid()} 开始执行")
    time.sleep(2)
    print(f"进程 {os.getpid()} 结束")

if __name__ == "__main__":
    p1 = multiprocessing.Process(target=process_task)
    p2 = multiprocessing.Process(target=process_task)

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print("所有进程完成")

3.2 进程池 Pool

from multiprocessing import Pool

def square(n):
    return n * n

if __name__ == "__main__":
    with Pool(4) as pool:
        results = pool.map(square, range(1, 6))
    print(results)  # [1, 4, 9, 16, 25]

4. asyncio —— 异步编程

4.1 定义异步函数

import asyncio

async def async_task(name):
    print(f"{name} 开始")
    await asyncio.sleep(2)
    print(f"{name} 完成")

async def main():
    await asyncio.gather(async_task("任务 1"),
        async_task("任务 2"),
        async_task("任务 3"),
    )

asyncio.run(main())

4.2 异步网络请求

使用 aiohttp 进行异步 HTTP 请求：

import aiohttp
import asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ["https://www.example.com"] * 3
    tasks = [fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

5. 小结与练习

今日总结

1. threading 适用于 I/O 密集型任务，如文件读写、网络请求。
2. multiprocessing 适用于 CPU 密集型任务，如数据计算。
3. asyncio 适用于高并发 I/O 任务，如 Web 服务器。

今日练习

1. 使用 threading 实现一个多线程爬虫。
2. 用 multiprocessing 计算 1~1000000 的平方和。
3. 用 asyncio 和 aiohttp 访问多个网站，并统计请求时间。

下一节预告 ：在 Day34，我们将探讨 Python 的 消息队列 和 协程调度，敬请期待！🚀