你是否曾经遇到过这样的情况：你写了一个看似完美的多线程程序，信心满满地运行它，然后… 噢不！某个线程像是进入了黑洞，再也没有回来。你焦急地等待，但它就是不肯结束。这种感觉，就像是你点了外卖，饿得前胸贴后背，但外卖小哥却在地图上原地打转。
今天，我们就来学习如何优雅地处理这种情况，让那些"迷路"的线程乖乖回家。我们的秘密武器是 func_timeout 包。它就像是给每个线程配备了一个严格的闹钟，时间一到，不管你是在梦周公还是在刷抖音，都得乖乖起床！
为什么需要 func_timeout？
在 Python 中，处理线程超时并不是一件容易的事。普通的 threading.Timer 或 concurrent.futures 的 wait 方法虽然可以设置超时，但它们只能让主线程不再等待，却无法真正终止那些超时的线程。
这就像是你在餐厅等位，服务员告诉你：“不好意思，您的等位时间到了，但是我们还是没有位置，您可以选择继续等或者离开。”——问题是，你都已经饿得前胸贴后背了，哪还有心情继续等？
而 func_timeout 就不一样了。它相当于餐厅经理亲自出马，说：“时间到了，我们马上给您安排一个座位，或者请您移步隔壁餐厅。”——干脆利落，不拖泥带水。
实战：如何优雅地处理超时线程
让我们通过一个简单的例子来看看 func_timeout 是如何拯救我们于水火之中的。
首先，我们来看看没有使用 func_timeout 的例子：
import concurrent.futures
import time
def worker(task_id):
print(f"任务 {task_id} 开始了。")
time.sleep(task_id) # 模拟任务执行时间
print(f"任务 {task_id} 结束了。")
def run_tasks():
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
futures = {executor.submit(worker, i): i for i in range(1, 6)}
done, not_done = concurrent.futures.wait(futures, timeout=3)
print(f"已完成的任务: {[futures[f] for f in done]}")
print(f"未完成的任务: {[futures[f] for f in not_done]}")
run_tasks()
print("所有任务已处理完毕")
任务 1 开始了。
任务 2 开始了。
任务 3 开始了。
任务 4 开始了。
任务 5 开始了。
任务 1 结束了。
任务 2 结束了。
任务 3 结束了。
任务 4 结束了。
任务 5 结束了。
已完成的任务: [1, 2]
未完成的任务: [3, 5, 4]
所有任务已处理完毕
import concurrent.futures
import queue
import time
# 定义一个简单的工作函数
def worker(task_id):
print(f"Task {task_id} started.")
time.sleep(task_id) # 模拟不同任务的执行时间
print(f"Task {task_id} END.")
# 记录开始时间
# start_time = time.time()
# 创建一个线程池并提交任务
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
futures = {executor.submit(worker, i): i for i in range(1, 6)}
concurrent.futures.wait(futures.keys(), timeout=3) # 设置超时时间为1秒
unfinished_tasks = [task_id for future, task_id in futures.items() if not future.done()]
if unfinished_tasks:
print(f"Tasks {unfinished_tasks} did not finish in time.")
print('finish')
Task 1 started.
Task 2 started.
Task 3 started.
Task 4 started.
Task 5 started.
Task 1 END.
Task 2 END.
Tasks [3, 4, 5] did not finish in time.
Task 3 END.
Task 4 END.
Task 5 END.
finish
看到问题了吗？虽然我们设置了 3 秒的超时，但那些超时的任务并没有真正停止，它们仍在后台默默运行，直到完成。这就像是你已经离开了餐厅，但厨师还在为你准备餐点 —— 这不仅浪费资源，还可能引发其他问题。
现在，让我们看看使用 func_timeout 的魔法：
import concurrent.futures
import func_timeout
import time
# 定义一个简单的工作函数
def worker(task_id):
print(f"Task {task_id} started.")
time.sleep(task_id) # 模拟不同任务的执行时间
print(f"Task {task_id} END.")
return task_id
# 包装工作函数以支持超时
def worker_with_timeout(task_id, timeout):
try:
return func_timeout.func_timeout(timeout, worker, args=(task_id,))
except func_timeout.FunctionTimedOut:
print(f"Task {task_id} timed out.")
return None
def test():
# 设置超时时间
timeout = 3
# 创建一个线程池并提交任务
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
futures = {executor.submit(worker_with_timeout, i, timeout): i for i in range(1, 6)}
# 等待所有任务完成
concurrent.futures.wait(futures.keys())
# 检查未完成的任务
unfinished_tasks = [task_id for future, task_id in futures.items() if not future.done() or future.result() is None]
if unfinished_tasks:
print(f"Tasks {unfinished_tasks} did not finish in time.")
# 获取已完成的任务结果
completed_tasks = [future.result() for future in futures.keys() if future.done() and future.result() is not None]
return completed_tasks
# 运行任务并获取结果
completed_tasks = test()
# 打印完成的任务结果
print('输出结果:')
print(f"Completed tasks: {completed_tasks}")
Task 2 started.
Task 1 started.
Task 3 started.
Task 4 started.
Task 5 started.
Task 1 END.
Task 2 END.
Task 3 timed out.
Task 4 timed out.
Task 5 timed out.
Tasks [3, 4, 5] did not finish in time.
输出结果:
Completed tasks: [1, 2]
import concurrent.futures
from func_timeout import func_timeout, FunctionTimedOut
import time
def worker(task_id):
print(f"任务 {task_id} 开始了。")
time.sleep(task_id) # 模拟任务执行时间
print(f"任务 {task_id} 结束了。")
return task_id
def worker_with_timeout(task_id, timeout):
try:
return func_timeout(timeout, worker, args=(task_id,))
except FunctionTimedOut:
print(f"任务 {task_id} 超时了！")
return None
def run_tasks():
timeout = 3
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
futures = {executor.submit(worker_with_timeout, i, timeout): i for i in range(1, 6)}
concurrent.futures.wait(futures)
completed = [f.result() for f in futures if f.result() is not None]
print(f"成功完成的任务: {completed}")
run_tasks()
print("所有任务真的处理完毕了！")
输出：
任务 1 开始了。
任务 2 开始了。
任务 3 开始了。
任务 4 开始了。
任务 5 开始了。
任务 1 结束了。
任务 2 结束了。
任务 3 超时了！
任务 4 超时了！
任务 5 超时了！
成功完成的任务: [1, 2]
所有任务真的处理完毕了！
瞧！那些超时的任务被干净利落地终止了，就像是餐厅经理挥一挥手，超时的客人就乖乖离开了一样。
总结
使用 func_timeout，我们可以：
- 真正地终止超时的线程，而不是让它们在后台继续运行。
- 更好地控制程序的执行时间，提高效率。
- 优雅地处理超时情况，不让一个任务拖累整个程序。
记住，在编程世界里，时间就是金钱，效率就是生命。善用 func_timeout，让你的程序不再"迷路"，准时"回家"。
下次当你的程序遇到那些顽固的、不愿意结束的线程时，别忘了召唤 func_timeout 这个法力无边的"线程终结者"。它会帮你把那些超时的线程送入温柔的离别之乡，让你的程序再次风驰电掣！
记住，在编程的世界里，有时候说再见，是为了更好的相遇。让我们一起，用 func_timeout 来编写更加高效、可靠的 Python 程序吧！
func_timeout 的工作原理是什么
- 信号机制
func_timeout 主要依赖于 Python 的信号（signal）机制。在 Unix-like 系统中（包括 Linux 和 macOS），它使用 SIGALRM 信号。
想象一下，这就像赛跑中的发令枪：
- 当函数开始执行时，func_timeout 设置了一个闹钟（通过 signal.alarm()）。
- 如果函数在指定时间内完成，闹钟被取消。
- 如果时间到了函数还没完成，闹钟"响起"（触发 SIGALRM 信号），函数被中断。
- 异常处理
当 SIGALRM 信号触发时，它会引发一个特殊的异常 FunctionTimedOut。
这就像赛跑中，如果选手没在规定时间内到达终点，裁判会吹哨子示意比赛结束：
- func_timeout 捕获这个异常。
- 然后它会清理现场（比如恢复原来的信号处理器）。
- 最后，它向调用者报告函数超时。
- 线程问题
这里有一个有趣的点：严格来说，func_timeout 并不能直接终止线程。在 Python 中，由于全局解释器锁（GIL）的存在，信号只能在主线程中处理。
这就像赛跑中，裁判只能在主赛道上吹哨子：
- 如果函数在主线程中运行，它可以被直接中断。
- 如果函数在子线程中运行，主线程会收到信号，但子线程可能会继续运行一段时间。
- 上下文切换
func_timeout 利用了 Python 的协作式多任务处理。当一个线程释放 GIL 时（比如在 I/O 操作或者每隔一定数量的字节码指令），Python 会检查是否有待处理的信号。
这就像在赛跑中，选手需要定期看一眼裁判，检查比赛是否结束：
如果检测到 SIGALRM，会引发异常。
这个异常会在下一个可能的时刻传播到子线程。
5. 清理工作
当函数被中断时，func_timeout 会尝试进行一些清理工作，比如恢复原来的信号处理器。
这就像赛跑结束后，需要清理赛道，恢复场地原貌。
总结一下，func_timeout 的工作原理就像是在一场有时间限制的赛跑中：
- 设置一个精确的计时器（闹钟）。
- 如果函数（选手）在时间内完成，一切正常。
- 如果时间到了函数还没完成，发出信号（吹哨子）。
- 捕获这个信号，并通过异常机制通知整个程序函数已超时。
- 最后进行必要的清理工作。
理解了这个原理，你就能更好地在实际编程中运用 func_timeout，并且意识到它的一些局限性（比如在多线程环境中的行为）。记住，虽然它很强大，但也不是万能的 —— 就像任何工具一样，了解它的工作原理可以帮助你更恰当地使用它！
扫一扫
1678
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
