Python 的 threading 模块是用于实现多线程编程的标准库之一。多线程允许程序在同一时间内执行多个任务，从而提高程序的效率和响应速度。

threading 模块提供了创建和管理线程的工具，使得开发者可以轻松地编写并发程序。

为什么使用多线程？

在单线程程序中，任务是一个接一个地顺序执行的。如果某个任务需要等待（例如等待网络响应或文件读取），整个程序会被阻塞，直到该任务完成。而多线程可以让程序在等待某个任务的同时，继续执行其他任务，从而提高程序的整体性能。

如何使用 threading 模块？

1. 创建线程

在 Python 中，可以通过继承 threading.Thread 类或直接使用 threading.Thread 构造函数来创建线程。

方法 1：继承 threading.Thread 类

实例

import threading
class MyThread(threading.Thread):
    def run(self):
        print("线程开始执行")
        # 在这里编写线程要执行的代码
        print("线程执行结束")
# 创建线程实例
thread = MyThread()

# 启动线程
thread.start()

# 等待线程执行完毕
thread.join()
print("主线程结束")

方法 2：使用 threading.Thread 构造函数

实例

import threading

def my_function():
    print("线程开始执行")
    # 在这里编写线程要执行的代码
    print("线程执行结束")

# 创建线程实例
thread = threading.Thread(target=my_function)

# 启动线程
thread.start()

# 等待线程执行完毕
thread.join()
print("主线程结束")

2. 线程同步

在多线程编程中，多个线程可能会同时访问共享资源，这可能导致数据不一致的问题。为了避免这种情况，可以使用线程同步机制，如锁（Lock）。

实例

import threading

# 创建一个锁对象
lock = threading.Lock()
def my_function():
    with lock:
        print("线程开始执行")
        # 在这里编写线程要执行的代码
        print("线程执行结束")
# 创建线程实例
thread1 = threading.Thread(target=my_function)
thread2 = threading.Thread(target=my_function)

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

# 等待线程执行完毕
thread1.join()
thread2.join()
print("主线程结束")

3. 线程间通信

线程间通信可以通过队列（Queue）来实现。Queue 是线程安全的，可以在多个线程之间安全地传递数据。

实例

import threading
import queue

def worker(q):
    while not q.empty():
        item = q.get()
        print(f"处理项目: {item}")
        q.task_done()
# 创建一个队列并填充数据
q = queue.Queue()
for i in range(10):
    q.put(i)

# 创建线程实例
thread1 = threading.Thread(target=worker, args=(q,))
thread2 = threading.Thread(target=worker, args=(q,))

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

# 等待队列中的所有项目被处理完毕
q.join()
print("所有项目处理完毕")

常用类、方法及属性

1. 核心类

2. Thread 对象常用方法/属性

3. Lock/RLock 常用方法

4. Event 常用方法

5. Condition 常用方法

6. 模块级函数/属性

实例

1. 基础线程创建

实例

import threading
def worker(num):
    print(f"Worker {num} started")
threads = []
for i in range(3):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()
for t in threads:
    t.join()

2. 使用锁保护共享资源

实例

lock = threading.Lock()
count = 0
def increment():
    global count
    with lock:  # 自动获取和释放锁
        count += 1
threads = [threading.Thread(target=increment) for _ in range(10)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(count)  # 输出: 10

3. 事件同步

实例

event = threading.Event()
def waiter():
    print("Waiting for event...")
    event.wait()
    print("Event triggered!")
t = threading.Thread(target=waiter)
t.start()
# 主线程触发事件
threading.Event().wait(2.0)  # 模拟延迟
event.set()
t.join()

4. 生产者-消费者模型（Condition）

实例

import random
from threading import Condition

queue = []
cond = Condition()
MAX_ITEMS = 5

def producer():
    for _ in range(10):
        with cond:
            while len(queue) >= MAX_ITEMS:
                cond.wait()
            item = random.randint(1, 100)
            queue.append(item)
            print(f"Produced {item}")
            cond.notify()
def consumer():
    for _ in range(10):
        with cond:
            while not queue:
                cond.wait()
            item = queue.pop(0)
            print(f"Consumed {item}")
            cond.notify()
threading.Thread(target=producer).start()
threading.Thread(target=consumer).start()

注意事项

1. 全局解释器锁（GIL）：Python 的 GIL 会限制同一时间只有一个线程执行 Python 字节码。因此，在 CPU 密集型任务中，多线程可能不会带来性能提升。对于 I/O 密集型任务，多线程仍然是有益的。

2. 线程安全：在多线程环境中，确保对共享资源的访问是线程安全的，避免数据竞争和死锁。

3. 线程数量：创建过多的线程可能会导致系统资源耗尽，影响程序性能。合理控制线程数量，或使用线程池（ThreadPoolExecutor）来管理线程。