Python 多線程編程的十個關鍵點
作者：小白PythonAI編程
本文將詳細介紹 Python 多線程編程的十個關鍵點，從基礎到高級，逐步引導你掌握這一強大工具。
多線程編程是 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 的多線程編程技術。
責任編輯：趙寧寧
來源：
小白PythonAI編程
