《人生苦短，我用python·八》多线程和线程池的使用

在Python中，多线程是一种并发编程技术，它允许多个线程在程序中并行执行。这对于IO密集型任务（如网络请求、文件读写等）非常有用，因为这些任务在等待外部资源时可以让其他线程继续工作，从而提高程序的效率。

1. 使用threading模块创建线程
Python内置的threading模块可以很方便地创建和管理线程。下面是一个简单的例子，展示如何创建和启动线程：

import threading
import timedef worker():print(f"Thread {threading.current_thread().name} is starting")time.sleep(2)print(f"Thread {threading.current_thread().name} is ending")# 创建线程
thread1 = threading.Thread(target=worker, name='Worker 1')
thread2 = threading.Thread(target=worker, name='Worker 2')# 启动线程
thread1.start()
thread2.start()# 等待线程完成
thread1.join()
thread2.join()print("All threads have finished execution")

在这个例子中，我们创建了两个线程，并启动它们。threading.current_thread().name用于获取当前线程的名称，time.sleep(2)用于模拟一个需要两秒钟完成的任务。

2. 使用Thread类创建自定义线程
你也可以通过继承threading.Thread类来创建自定义线程类：

class MyThread(threading.Thread):def __init__(self, name):super().__init__()self.name = namedef run(self):print(f"Thread {self.name} is starting")time.sleep(2)print(f"Thread {self.name} is ending")# 创建线程
thread1 = MyThread(name='Worker 1')
thread2 = MyThread(name='Worker 2')# 启动线程
thread1.start()
thread2.start()# 等待线程完成
thread1.join()
thread2.join()print("All threads have finished execution")

3. 使用线程池（concurrent.futures模块）
对于需要管理大量线程的情况，使用线程池更为方便。Python的concurrent.futures模块提供了一个高层次的接口来创建和管理线程池。

from concurrent.futures import ThreadPoolExecutor
import timedef worker(name):print(f"Thread {name} is starting")time.sleep(2)print(f"Thread {name} is ending")# 创建线程池
with ThreadPoolExecutor(max_workers=2) as executor:futures = [executor.submit(worker, f'Worker {i}') for i in range(1, 3)]# 等待所有线程完成
for future in futures:future.result()print("All threads have finished execution")

在这个例子中，我们创建了一个包含两个工作线程的线程池，并提交了两个任务给线程池执行。

4. 线程同步
在多线程编程中，同步是一个重要的概念。Python提供了多种同步原语，比如锁（Lock）、条件变量（Condition）、事件（Event）等。下面是一个使用锁的例子：

import threadinglock = threading.Lock()def worker_with_lock(name):print(f"Thread {name} is waiting for the lock")with lock:print(f"Thread {name} has acquired the lock")time.sleep(2)print(f"Thread {name} is releasing the lock")thread1 = threading.Thread(target=worker_with_lock, args=('Worker 1',))
thread2 = threading.Thread(target=worker_with_lock, args=('Worker 2',))thread1.start()
thread2.start()thread1.join()
thread2.join()print("All threads have finished execution")

在这个例子中，使用了threading.Lock来确保同一时刻只有一个线程可以访问共享资源。

5. 线程间通信
Python的queue模块提供了一个线程安全的队列，可以用来在线程之间传递数据：

import threading
import queue
import timedef producer(q):for i in range(5):print(f"Producing {i}")q.put(i)time.sleep(1)def consumer(q):while True:item = q.get()if item is None:breakprint(f"Consuming {item}")q = queue.Queue()
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()print("All threads have finished execution")