多线程编程是 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()输出结果：
0
1
2
3
4
5
6
7
8
92. 创建和启动线程
创建线程
可以通过继承 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()输出结果：
Thread Thread 1: 0
Thread Thread 2: 0
Thread Thread 1: 1
Thread Thread 2: 1
...
Thread Thread 1: 9
Thread Thread 2: 93. 线程同步
线程同步问题
多个线程同时访问共享资源时可能会导致数据不一致的问题。为了防止这种情况，可以使用锁（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}")输出结果：
Final counter value: 2000004. 线程间通信
使用队列进行线程间通信
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()输出结果：
Produced: 0
Consumed: 0
Produced: 1
Consumed: 1
...
Produced: 9
Consumed: 95. 线程池
使用 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)输出结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]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()输出结果：
Thread Thread 1 set value to 10
Thread Thread 2 got value: 107. 守护线程
守护线程
守护线程（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")输出结果：
Daemon thread running...
Daemon thread running...
Daemon thread running...
Daemon thread running...
Daemon thread running...
Main thread finished8. 线程优先级
线程优先级
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()输出结果：
Processing item with priority 1: High priority task
Processing item with priority 2: Medium priority task
Processing item with priority 3: Low priority task9. 线程安全的数据结构
线程安全的数据结构
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)}")输出结果：
Added A to the list
Added B to the list
Final list: ['A', 'B']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()输出结果：
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.jpg总结
本文详细介绍了 Python 多线程编程的 10 个关键点，包括线程的基本概念、创建和启动线程、线程同步、线程间通信、线程池、线程局部存储、守护线程、线程优先级、线程安全的数据结构以及一个实战案例。通过这些内容，你应该能够更好地理解和应用 Python 的多线程编程技术。
