多线程中实现回调链的核心是任务完成后触发下一个函数，可通过threading.Thread配合队列或concurrent.futures的Future对象实现，后者利用add_done_callback注册回调，形成链式结构，适用于I/O密集型任务且需与非异步库集成的场景。

多线程中实现回调链的基本思路

在Python中，多线程本身并不直接支持异步回调链，但可以通过 threading.Thread 配合队列或回调函数手动构建回调机制。回调链的核心是：一个任务执行完成后，自动触发下一个函数。这在需要串行处理多个耗时操作时非常有用。

实现方式的关键点：

• 使用 Queue 在线程间传递结果和下一步动作
• 每个任务执行完后调用预设的回调函数
• 回调函数可以是下一个任务的入口，从而形成“链”

示例代码：

import threading
import queue
import time
def task1(callback):
print("任务1开始")
time.sleep(1)
result = "结果1"
print("任务1完成")
callback(result)
def task2(data, callback):
print(f"任务2接收: {data}")
time.sleep(1)
result = data + " -> 结果2"
print("任务2完成")
callback(result)
def task3(data):
print(f"任务3接收: {data}")
print("回调链结束")
回调链连接
def start_chain():
def on_task1_done(res):
task2(res, task3)
thread = threading.Thread(target=task1, args=(on_task1_done,))
thread.start()
start_chain()

使用 concurrent.futures 简化回调管理

concurrent.futures 模块提供了更高级的线程控制方式，尤其是 ThreadPoolExecutor 和 Future 对象，天然支持任务完成后的回调注册。

通过 future.add_done_callback() 可以注册任务完成后的回调函数，实现清晰的回调链结构。

示例：

from concurrent.futures import ThreadPoolExecutor
import time
def step1(x):
time.sleep(1)
return f"step1({x})"
def step2(future):
result = future.result()
print(f"进入 step2，输入: {result}")
time.sleep(1)
return f"step2({result})"
def step3(future):
result = future.result()
print(f"进入 step3，输入: {result}")
time.sleep(1)
print("回调链完成:", result)
def run_with_callback_chain():
with ThreadPoolExecutor(max_workers=3) as executor:
第一步
    future1 = executor.submit(step1, "init")

    # 第二步绑定到第一步完成
    future1.add_done_callback(
        lambda f: executor.submit(step2, f).add_done_callback(step3)
    )
run_with_callback_chain()

说明：

• submit 返回 Future 对象，代表异步任务
• add_done_callback 注册回调，任务完成后自动执行
• 可以在回调中继续提交新任务并绑定下一级回调，形成链式结构

对比 asyncio：何时用多线程回调？

虽然 Python 的 asyncio 更适合异步编程，但在以下场景中，多线程 + 回调链仍有优势：

• CPU密集型任务较少，主要是 I/O 操作（如网络请求、文件读写）
• 需与不支持 async 的第三方库集成
• 希望保持代码简单，不引入事件循环复杂度

注意：由于 GIL 存在，多线程无法真正并行执行 CPU 密集任务。若需并行计算，应考虑 multiprocessing 或 asyncio + 线程池混合方案。

回调链的常见问题与优化建议

实际使用中容易遇到的问题：

• 回调地狱：嵌套过多导致代码难以维护
• 异常未捕获：回调中出错不会中断主线程
• 资源泄漏：线程未正确关闭或回调未释放引用

优化建议：

• 封装回调逻辑为独立函数，避免匿名函数过长
• 在每个回调中加入 try-except 处理异常
• 使用上下文管理器（with）确保线程池正确关闭
• 考虑将回调链抽象成 Pipeline 类，提升可读性

基本上就这些。多线程回调链虽不如 async/await 直观，但在特定场景下依然是一种实用的异步编程模式。