python线程间怎么通信

Python 线程间通信（Inter-Thread Communication, ITC）是理解并发编程的核心之一。

由于同一进程内的所有线程共享内存空间，它比进程间通信（IPC）更高效，但也更危险 ------ 稍不注意就会出现数据竞争、死锁等问题。

🧠 一、线程之间为什么要通信？

多线程的目的是让多个任务并行执行（例如 I/O 并发、后台计算、异步日志等）。

但这些线程往往需要共享数据或协调动作，比如：

• 一个线程生产数据，另一个线程消费；

• 主线程通知子线程停止；

• 多线程同时写日志；

• 多线程之间需要同步状态。

因此，需要安全的通信机制来传递数据、协调执行。

⸻

🧩 二、线程间通信的基本特征

⸻

⚙️ 三、常见的通信与同步机制

Python 提供了多种线程间通信方式，主要有以下几类：

⸻

🔹 1. Queue --- 最推荐的通信方式

queue.Queue 是线程安全的 FIFO 队列（内部用锁同步），适合"生产者-消费者"模型。

📘 示例：生产者与消费者

bash 复制代码

import threading, queue, time

q = queue.Queue(maxsize=5)

def producer():
    for i in range(10):
        item = f"任务-{i}"
        q.put(item)      # 自动加锁
        print(f"生产：{item}")
        time.sleep(0.5)

def consumer():
    while True:
        item = q.get()   # 自动等待可用
        print(f"消费：{item}")
        time.sleep(1)
        q.task_done()

threading.Thread(target=producer).start()
threading.Thread(target=consumer, daemon=True).start()

q.join() # 等所有任务完成

✅ 优点：

• 自动线程安全；

• 支持阻塞/非阻塞；

• 自带 join / task_done 协调机制；

• 可实现多生产者、多消费者模型。

⸻

🔹 2. Event --- 信号通知机制

Event 是一种线程间事件信号：

一个线程等待事件，另一个线程触发事件。

📘 示例

bash 复制代码

import threading, time

event = threading.Event()

def worker():
    print("子线程等待信号...")
    event.wait()          # 阻塞，直到被 set()
    print("收到信号，继续执行！")

t = threading.Thread(target=worker)
t.start()

time.sleep(2)
print("主线程发信号")
event.set()               # 唤醒 worker
t.join()

✅ 优点：

• 实现线程之间的同步信号；

• 适合"启动/暂停/终止"等场景；

• 不需要共享数据。

⸻

🔹 3. Condition --- 条件变量（适合复杂等待）

用于复杂的同步条件，比如：等待"队列非空"或"资源可用"。

📘 示例

bash 复制代码

import threading, time

cond = threading.Condition()
data = []

def producer():
    with cond:
        print("生产者：准备数据")
        data.append("任务数据")
        cond.notify()  # 唤醒等待的消费者

def consumer():
    with cond:
        print("消费者：等待数据")
        cond.wait()    # 等待 notify()
        print("消费者：获取数据", data.pop())

threading.Thread(target=consumer).start()
time.sleep(1)
threading.Thread(target=producer).start()

✅ 特点：

• 可精确控制等待条件；

• 可配合多个线程使用；

• 是更底层的同步机制。

⸻

🔹 4. Lock / RLock --- 最基础的同步方式

用于保护共享资源，防止并发修改冲突。

📘 示例

bash 复制代码

import threading, time

lock = threading.Lock()
counter = 0

def worker():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

threads = [threading.Thread(target=worker) for _ in range(5)]
[t.start() for t in threads]
[t.join() for t in threads]
print("最终结果:", counter)

如果没有锁保护，多线程同时修改 counter，结果会错误。

✅ 区别：

• Lock：普通互斥锁；

• RLock：可重入锁（允许同一线程重复获得）。

⸻

🔹 5. Semaphore --- 控制并发数量

类似计数锁，可用于限制并发资源访问数量。

📘 示例

bash 复制代码

import threading, time

sem = threading.Semaphore(3)  # 最多允许3个线程同时执行

def worker(i):
    with sem:
        print(f"线程 {i} 开始")
        time.sleep(2)
        print(f"线程 {i} 结束")

for i in range(8):
    threading.Thread(target=worker, args=(i,)).start()

✅ 应用：

• 限制数据库连接数；

• 控制文件下载并发数。

⸻

🔹 6. 全局变量（不推荐直接用）

线程共享全局变量，但需要锁保护。

📘 示例

bash 复制代码

import threading

shared_data = 0
lock = threading.Lock()

def add():
    global shared_data
    for _ in range(100000):
        with lock:
            shared_data += 1

threads = [threading.Thread(target=add) for _ in range(5)]
[t.start() for t in threads]
[t.join() for t in threads]
print("结果:", shared_data)

⸻

🔹 7. Future / ThreadPoolExecutor（现代线程通信）

Python 的 concurrent.futures 封装了线程池和异步返回结果机制（Future 对象）。

📘 示例

from concurrent.futures import ThreadPoolExecutor, as_completed

import time

def task(x):

time.sleep(1)

return x * x

with ThreadPoolExecutor(max_workers=4) as executor:

futures = [executor.submit(task, i) for i in range(6)]

for f in as_completed(futures):

print("结果:", f.result())

✅ 优点：

• 自带队列与锁；

• 线程安全；

• 结果异步返回（Future.result()）。

⸻

🧮 四、性能与适用场景对比

⸻

🧭 五、线程间通信的设计建议

✅ 优先使用 Queue：最稳定、线程安全、简单。
⚠️ 全局变量必须加锁：否则容易出现竞争条件。
🧱 不要过度使用锁：过多锁会导致死锁、性能下降。
🚀 I/O 密集用多线程，CPU 密集用多进程。
🧰 复杂同步逻辑用 Event / Condition 实现。
🧮 任务分发场景可用 ThreadPoolExecutor。

⸻

✅ 六、总结对比表