Python 多线程编程的十个关键点-51CTO.COM

多线程编程是 Python 中一个非常重要的主题，它可以帮助你在处理并发任务时提高程序的效率。本文将详细介绍 Python 多线程编程的 10 个关键点，从基础到高级，逐步引导你掌握这一强大工具。

1. 线程的基本概念

什么是线程？

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以包含多个线程，这些线程共享进程的资源，如内存和文件句柄。

Python 中的线程

在 Python 中，我们可以使用 threading 模块来创建和管理线程。下面是一个简单的示例：

import threading

def print_numbers():
    for i in range(10):
        print(i)

# 创建线程
thread = threading.Thread(target=print_numbers)

# 启动线程
thread.start()

# 等待线程完成
thread.join()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

输出结果：

0
1
2
3
4
5
6
7
8
91.
2.
3.
4.
5.
6.
7.
8.
9.
10.

2. 创建和启动线程

创建线程

可以通过继承 Thread 类来创建自定义线程类，然后重写 run 方法来定义线程的行为。

import threading

class MyThread(threading.Thread):
    def run(self):
        for i in range(10):
            print(f"Thread {self.name}: {i}")

# 创建线程实例
thread1 = MyThread(name="Thread 1")
thread2 = MyThread(name="Thread 2")

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

# 等待线程完成
thread1.join()
thread2.join()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

输出结果：

Thread Thread 1: 0
Thread Thread 2: 0
Thread Thread 1: 1
Thread Thread 2: 1
...
Thread Thread 1: 9
Thread Thread 2: 91.
2.
3.
4.
5.
6.
7.

3. 线程同步

线程同步问题

多个线程同时访问共享资源时可能会导致数据不一致的问题。为了防止这种情况，可以使用锁（Lock）来同步线程。

import threading

# 共享资源
counter = 0

# 锁
lock = threading.Lock()

def increment_counter():
    global counter
    for _ in range(100000):
        lock.acquire()  # 获取锁
        counter += 1
        lock.release()  # 释放锁

# 创建线程
thread1 = threading.Thread(target=increment_counter)
thread2 = threading.Thread(target=increment_counter)

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

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

print(f"Final counter value: {counter}")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

输出结果：

Final counter value: 2000001.

4. 线程间通信

使用队列进行线程间通信

queue 模块提供了线程安全的队列，可以用于线程间的通信。

import threading
import queue

# 创建队列
q = queue.Queue()

def producer(q):
    for i in range(10):
        q.put(i)
        print(f"Produced: {i}")

def consumer(q):
    while True:
        item = q.get()
        if item is None:
            break
        print(f"Consumed: {item}")
        q.task_done()

# 创建线程
producer_thread = threading.Thread(target=producer, args=(q,))
consumer_thread = threading.Thread(target=consumer, args=(q,))

# 启动线程
producer_thread.start()
consumer_thread.start()

# 等待生产者完成
producer_thread.join()

# 停止消费者
q.put(None)
consumer_thread.join()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

输出结果：

Produced: 0
Consumed: 0
Produced: 1
Consumed: 1
...
Produced: 9
Consumed: 91.
2.
3.
4.
5.
6.
7.

5. 线程池

使用 concurrent.futures 模块

concurrent.futures 模块提供了线程池的实现，可以简化多线程编程。

import concurrent.futures

def task(n):
    return n * n

# 创建线程池
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(task, range(10)))

print(results)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

输出结果：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]1.

6. 线程局部存储

线程局部存储

线程局部存储（Thread-local storage）允许每个线程拥有其自己的局部变量副本，这些变量不会被其他线程访问。

import threading

# 创建线程局部存储
local_storage = threading.local()

def set_local_value(value):
    local_storage.value = value
    print(f"Thread {threading.current_thread().name} set value to {value}")

def get_local_value():
    try:
        print(f"Thread {threading.current_thread().name} got value: {local_storage.value}")
    except AttributeError:
        print(f"Thread {threading.current_thread().name} has no value")

# 创建线程
thread1 = threading.Thread(target=set_local_value, args=(10,), name="Thread 1")
thread2 = threading.Thread(target=get_local_value, name="Thread 2")

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

thread2.start()
thread2.join()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

输出结果：

Thread Thread 1 set value to 10
Thread Thread 2 got value: 101.
2.

7. 守护线程

守护线程

守护线程（Daemon thread）是一种在后台运行的线程，当所有非守护线程结束后，守护线程会自动结束。

import threading
import time

def daemon_thread():
    while True:
        print("Daemon thread running...")
        time.sleep(1)

# 创建守护线程
daemon = threading.Thread(target=daemon_thread, daemon=True)

# 启动守护线程
daemon.start()

# 主线程运行一段时间后结束
time.sleep(5)
print("Main thread finished")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

输出结果：

Daemon thread running...
Daemon thread running...
Daemon thread running...
Daemon thread running...
Daemon thread running...
Main thread finished1.
2.
3.
4.
5.
6.

8. 线程优先级

线程优先级

Python 的 threading 模块不直接支持设置线程优先级，但可以通过一些间接方法来实现。例如，可以使用 queue.PriorityQueue 来管理任务的优先级。

import threading
import queue

# 创建优先级队列
q = queue.PriorityQueue()

def worker():
    while True:
        priority, item = q.get()
        if item is None:
            break
        print(f"Processing item with priority {priority}: {item}")
        q.task_done()

# 创建线程
worker_thread = threading.Thread(target=worker, daemon=True)

# 启动线程
worker_thread.start()

# 添加任务
q.put((1, "High priority task"))
q.put((3, "Low priority task"))
q.put((2, "Medium priority task"))

# 等待所有任务完成
q.join()

# 停止线程
q.put((None, None))
worker_thread.join()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.

输出结果：

Processing item with priority 1: High priority task
Processing item with priority 2: Medium priority task
Processing item with priority 3: Low priority task1.
2.
3.

9. 线程安全的数据结构

线程安全的数据结构

Python 的 queue 模块提供了线程安全的队列，此外，还可以使用 multiprocessing 模块中的 Manager 类来创建线程安全的数据结构。

import threading
from multiprocessing import Manager

# 创建线程安全的列表
manager = Manager()
safe_list = manager.list()

def add_to_list(item):
    safe_list.append(item)
    print(f"Added {item} to the list")

# 创建线程
thread1 = threading.Thread(target=add_to_list, args=("A",))
thread2 = threading.Thread(target=add_to_list, args=("B",))

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

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

print(f"Final list: {list(safe_list)}")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

输出结果：

Added A to the list
Added B to the list
Final list: ['A', 'B']1.
2.
3.

10. 实战案例：多线程下载图片

案例背景

假设我们需要从多个 URL 下载图片并保存到本地。使用多线程可以显著提高下载速度。

import os
import requests
import threading

# 图片 URL 列表
image_urls = [
    "https://example.com/image1.jpg",
    "https://example.com/image2.jpg",
    "https://example.com/image3.jpg"
]

# 保存图片的目录
save_dir = "images"

# 创建目录
if not os.path.exists(save_dir):
    os.makedirs(save_dir)

def download_image(url):
    response = requests.get(url)
    if response.status_code == 200:
        filename = os.path.join(save_dir, url.split("/")[-1])
        with open(filename, "wb") as f:
            f.write(response.content)
        print(f"Downloaded {url} to {filename}")
    else:
        print(f"Failed to download {url}")

# 创建线程
threads = []
for url in image_urls:
    thread = threading.Thread(target=download_image, args=(url,))
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

输出结果：

Downloaded https://example.com/image1.jpg to images/image1.jpg
Downloaded https://example.com/image2.jpg to images/image2.jpg
Downloaded https://example.com/image3.jpg to images/image3.jpg1.
2.
3.

总结

本文详细介绍了 Python 多线程编程的 10 个关键点，包括线程的基本概念、创建和启动线程、线程同步、线程间通信、线程池、线程局部存储、守护线程、线程优先级、线程安全的数据结构以及一个实战案例。通过这些内容，你应该能够更好地理解和应用 Python 的多线程编程技术。