Threading 多线程模块

Python 的 threading 模块提供了多线程编程的能力，允许程序在同一进程中并发执行多个任务。虽然由于全局解释器锁（GIL）的存在，Python 线程不适合 CPU 密集型任务，但在 I/O 密集型任务中非常有效。

基本类

• Thread 类 - 表示执行线程的主要类

  import threading
  import time
  
  # 定义一个简单的线程任务
  def worker(thread_id, delay):
      print(f"线程 {thread_id} 开始执行")
      time.sleep(delay)
      print(f"线程 {thread_id} 执行完成，等待了 {delay} 秒")
  
  # 创建并启动线程
  threads = []
  for i in range(5):
      t = threading.Thread(target=worker, args=(i, i+1))  
      threads.append(t)
      t.start()  # 启动线程活动。它在一个单独的线程中调用 run() 方法。
  
  # 等待所有线程完成
  for t in threads:
      t.join()  # 等待，直到线程终止。这会阻塞调用线程（通常是主线程），直到被调用 join() 的所有线程执行完毕。
  
  print("所有线程执行完毕")
  

• Lock类：基本互斥锁

  import threading
  
  # 共享资源
  counter = 0
  lock = threading.Lock()   # 创建同步锁对象
  
  def increment():
      global counter
      for _ in range(10):
          # 获取锁
          lock.acquire()  # 获取锁。如果锁已被占用，则阻塞等待，直到锁被释放。确保一次只有一个线程进入“房间”。
          try:
              counter += 1
          finally:
              # 释放锁
              lock.release() # 释放锁。让其他等待的线程可以获取到锁。忘记做这件事后果很严重（死锁）！
  
  # 创建多个线程
  threads = []
  for _ in range(10):
      t = threading.Thread(target=increment)
      threads.append(t)
      t.start()
  
  # 等待所有线程完成
  for t in threads:
      t.join()
  
  print(f"最终计数器值: {counter}")
  

使用queue队列，多线程消费者模式

爬虫或其他 I/O 密集型任务，将任务加入队列，以多线程取消费，提高任务速度。

import threading
import queue
import time
import random


# 线程池调度
class ThreadPool:
    def __init__(self,num_workers):
        self.task_queue = queue.Queue() # 任务队列
        self.workers = []  # 线程池
        self.running = False # 线程启动标志
        self.num_workers = num_workers # 线程数

    def start(self):
        """ 启动工作线程池"""
        self.running = True
        for i in range(self.num_workers):
            worker = threading.Thread(target=self.target_func,name=f"worker-{i+1}")
            worker.daemon = True # 守护线程，主线程结束时自动退出
            worker.start()
            self.workers.append(worker)
            
    def target_func(self):
        """工作线程主循环"""
        while self.running:
            try:
                # 执行任务
                task = self.task_queue.get(timeout=1)
                if task == None:
                    self.task_queue.task_done()
                    break
                    
                func,args,kwargs = task
                try:
                    func(*args,**kwargs)
                except Exception as e:
                    print(f'任务执行出错：{e}')
                finally:
                    self.task_queue.task_done() # 标记任务完成
            except queue.Empty:
                continue # 队列为空时是继续等待
                
    def add_task(self,func,*args,**kwargs):
        """ 添加任务到队列"""
        if  self.running:
            self.task_queue.put((func,args,kwargs))
        else:
            print('警告：线程池已经停止，无法添加新任务')

    def _wait_completion(self):
        """等待队列所有任务完成"""
        self.task_queue.join()

    def stop(self,graceful=True):
        """ 停止所有工作线程"""
        if graceful:
            self._wait_completion()
            print('队列所有任务已完成，准备停止线程池')      
            
            # 向每个工作线程发送停止信号
            for _ in range(self.num_workers):
                 self.task_queue.put(None)

        self.running = False

        # 等待所有工作线程结束
        for worker in self.workers:
            worker.join()
            
        print('所有工作线程结束')