返回资讯中心
外部精选
软件工程
#开发者实时流

研究揭示超时后工作仍在继续:跨四种语言追踪取消机制

来源标题:What Happens to Work After a Timeout?

一项实验发现,超时返回错误后底层操作仍会继续执行——在 Node.js 和 Python 测试中,调用方约 100 毫秒后超时,而工作又持续了约 250 毫秒才完成。该研究追踪了 JavaScript、Python、Go 和 Rust 中的取消机制,并说明如何避免由此产生的问题。

Hacker News 最新khalidkhair2026/11/16 · 昨天30 分钟阅读

以下正文由 AI 翻译自 Hacker News 最新(原文版权归原站所有),可能存在偏差,重要内容请以原文为准。

超时能返回错误,但工作还在继续跑。我们追踪了 JavaScript、Python、Go 和 Rust 中的取消机制,并展示如何避免由此带来的后果。

超时是保护应用免受慢操作影响的最简单方法之一。给请求设定一个截止时间,到期就停止等待并返回错误。

但错误返回之后,那个操作会怎样?

为了调查这个问题,我们做了一个小实验。一个操作需要 350 毫秒完成,而它的调用方只等待 100 毫秒。我们在 Node.js 和 Python 中运行了等价的版本。

Node.js 22.16.0 100ms 调用方超时 350ms 工作完成

Python 3.13.5 101ms 调用方超时 351ms 工作完成

超时按配置生效了:调用方在大约 100 毫秒后重新获得控制权。底层工作又继续运行了四分之一秒。

这种区别很容易被忽视,因为大多数超时实现都是通过测量它们返回的速度来评估的。一旦调用方收到错误,应用往往就不再追踪产生该错误的操作了。

对于定时器来说,后果是无害的。但对于数据库查询、后台 worker 或修改持久状态的请求来说,它可能导致资源浪费、重试重叠,以及操作在调用方早已放弃很久之后才完成。

JavaScript、Python、Go 和 Rust 都提供了限制异步工作的机制。它们的实现各不相同,但底层问题是共通的:结束等待并不一定结束被等待的工作。

调用方的截止时间和操作的生命周期是两种不同的度量。

JavaScript 提供了一种便捷的方式,可以用 Promise.race() 对任意 promise 施加超时:

function withTimeout(operation, ms) {
 return Promise.race([
 operation,
 new Promise((_, reject) => {
 setTimeout(() => reject(new Error("Timed out")), ms);
 }),
 ]);
}

该函数创建两个 promise。一个代表操作,另一个在指定时长后拒绝。谁先 settle,谁就决定返回给调用方的值。

我们用一个耗时 350 毫秒的操作进行了测试:

const start = performance.now();
function log(message) {
 const elapsed = Math.round(performance.now() - start);
 console.log(`${elapsed}ms ${message}`);
}
const work = new Promise((resolve) => {
 setTimeout(() => {
 log("Work completed");
 resolve();
 }, 350);
});
try {
 await withTimeout(work, 100);
} catch {
 log("Caller timed out");
}

调用方在大约 100 毫秒后报告超时,但操作仍然在大约 350 毫秒时打印了完成消息。

这并不涉及什么异常的调度行为。这直接源于 Promise.race() 的约定。promise 代表一个最终结果。让竞速 settle 并不会指示落败的 promise 停止,work 所调度的定时器仍然留在事件循环中。

同样的问题也出现在 HTTP 代码中,当 fetch 只是与一个超时 promise 竞速时:

await Promise.race([
 fetch(url),
 timeout(1000), // 一个普通的 promise,1 秒后拒绝
]);

如果超时赢了,返回的 promise 就会拒绝。fetch 并没有被指示中止。如果操作先完成,超时自己的定时器也应该被清除;否则它又是另一个被遗留的工作。

Promise.race() 在第一个事件处 settle 结果;它不会取消另一个操作。

JavaScript 为支持取消的 API 提供了 AbortController 和 AbortSignal。对于 fetch(),超时可以附加到操作本身上:

const response = await fetch(url, {
 signal: AbortSignal.timeout(1000),
});

当信号到期时,Fetch API 可以中止其工作并拒绝关联的 promise。这比让两个不相关的 promise 竞速更强。

然而,这并不能确定远程服务器停止了处理请求。服务器可能已经收到了请求,或者在得知客户端断开之前就已经提交了事务。

Python 的 asyncio 使用不同的取消模型。asyncio.wait_for() 在截止时间到期时请求取消。挂起在 await 点的协程可以收到 asyncio.CancelledError,并在终止前运行清理代码。

import asyncio

async def work():
 try:
 await asyncio.sleep(10)
 finally:
 print("Cleaning up")

async def main():
 try:
 await asyncio.wait_for(work(), timeout=0.1)
 except TimeoutError:
 print("Timed out")

asyncio.run(main())

这里的取消在协程挂起于 asyncio.sleep() 时中断了它。它的 finally 块在调用方收到超时之前执行。

import asyncio
import time

start = time.perf_counter()

def blocking_work():
 time.sleep(0.35)
 print(f"{(time.perf_counter() - start) * 1000:.0f}ms Work completed")

async def main():
 try:
 await asyncio.wait_for(
 asyncio.to_thread(blocking_work),
 timeout=0.1,
 )
 except TimeoutError:
 print(f"{(time.perf_counter() - start) * 1000:.0f}ms Caller timed out")

asyncio.run(main())

等待结果的 asyncio 任务被取消了。然而,一旦阻塞函数在线程中开始执行,它的执行就不会被强制终止。在我们的运行中,调用方在 101 毫秒时超时,线程在 351 毫秒时打印了完成消息。

Python 通常无法安全地杀死任意线程。它可能持有锁、正在修改共享对象,或者正处于没有取消机制的代码中间。worker 被允许独立完成。

还有另一个微妙之处:asyncio.wait_for() 通常会等待取消完成。一个执行冗长清理、或故意抑制取消的协程,可能导致它超出名义上的超时。截止时间并不一定是 wait_for() 中总耗时的硬性上限。

Go 通过 context.Context 来处理取消。context 可以沿调用链向下传递截止时间,当其被取消时,它的 Done() channel 会关闭。

(原文较长,此处译出前 6000 字,完整内容请点「打开原文」。)

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →