HarmonyOS鸿蒙Next中ArkTS可以在超时后取消任务吗？

为 Promise 添加超时功能的包装函数

@template T - Promise 返回值的类型

@param p - 需要添加超时控制的 Promise

@param ms - 超时时间(毫秒)

@returns 返回一个新的 Promise，如果原 Promise 在指定时间内没有 settle，则会 reject

注意：此函数无法真正"取消"原 Promise 的执行，只是不再等待其结果
/

function withTimeout<T>(p: Promise<T>, ms: number): Promise<T> {
  // 如果超时时间小于等于0，直接返回原 Promise，不做超时处理
  if (ms <= 0) return p;
  // 返回一个新的 Promise 来包装原 Promise 和超时逻辑
  return new Promise<T>((resolve, reject) => {
    // 创建一个定时器，在指定时间后触发超时
    // 如果定时器触发，说明原 Promise 在规定时间内没有 settle，直接 reject
    const t = setTimeout(() => {
      reject(new Error(`Timeout: ${ms}ms`))
    }, ms);
    // 监听原 Promise 的结果
    p.then(
      // 成功回调：原 Promise 在超时前 resolve 了
      (v: T) => {
        clearTimeout(t);  // 清除超时定时器，避免超时 reject 被触发
        resolve(v);       // 将原 Promise 的成功值传递给新 Promise
        console.log(`resolved!`);
      },
      // 失败回调：原 Promise 在超时前 reject 了
      (e: Error) => {
        clearTimeout(t);  // 清除超时定时器
        reject(e);        // 将原 Promise 的错误传递给新 Promise
        console.log(`rejected!`);
      }
    );
  });
}

=== 重要说明 ===

此函数存在的局限性：

1. Promise 一旦创建就无法真正"取消"或"杀死"
2. 即使超时了，原 Promise p 依然会继续运行
3. p.then() 回调仍会在未来某个时间点被执行（如果 p 最终 settle 了）
4. 超时后只是不再等待原 Promise 的结果，但无法阻止其继续执行

=== ArkTS 中可能的解决方案 ===

在 ArkTS/JavaScript 中，Promise 本身不支持取消机制，但可以考虑：

方案1：使用 AbortController（如果底层操作支持） 适用于网络请求等可中断的异步操作

方案2：使用任务标志位 在异步任务内部检查标志位，决定是否继续执行

方案3：使用 Worker 线程（HarmonyOS 中的 TaskPool） 可以真正终止独立线程中的任务

方案4：在业务层面忽略超时后的结果 虽然任务继续执行，但通过状态标志忽略其返回值

// === 使用示例 === // 示例1：正常情况 - Promise 在超时前完成

async function example1() {
  const normalPromise = new Promise<string>((resolve) => {
    setTimeout(() => resolve("成功完成"), 1000);
  });
  try {
    const result = await withTimeout(normalPromise, 2000);
    console.log(result); // 输出: "成功完成"
  } catch (e) {
    console.error(e);
  }
}

// 示例2：超时情况 - Promise 超时

async function example2() {
  const slowPromise = new Promise<string>((resolve) => {
    setTimeout(() => resolve("太慢了"), 3000);
  });
  try {
    const result = await withTimeout(slowPromise, 1000);
    console.log(result);
  } catch (e) {
    console.error(e); // 输出: Error: Timeout: 1000ms
  }
}

=== HarmonyOS 特定解决方案：使用 TaskPool 实现可取消任务 ===

如果需要真正"杀死"任务，可以使用 HarmonyOS 的 TaskPool API TaskPool 支持任务终止功能

import { taskpool } from '@kit.ArkTS';

// 定义一个可以被终止的长时间运行任务
@Concurrent
function longRunningTask(data: number): number {
  // 模拟长时间计算
  let result = 0;
  for (let i = 0; i < 1000000000; i++) {
    result += i;
  }
  return result;
}

async function withTimeoutAndCancel<T>(taskFunc: Function, args: unknown[], ms: number): Promise<T> {
  // 创建任务
  const task = new taskpool.Task(taskFunc, ...args);
  // 执行任务
  const taskGroup = new taskpool.TaskGroup();
  taskGroup.addTask(task);
  return new Promise<T>((resolve, reject) => {
    let isSettled = false;
    // 设置超时
    const timer = setTimeout(() => {
      if (!isSettled) {
        isSettled = true;
        // 取消任务组中的所有任务
        taskpool.cancel(taskGroup);
        reject(new Error(`Timeout: ${ms}ms`));
      }
    }, ms);
    // 执行任务
    taskpool.execute(task)
      .then((result: T) => {
        if (!isSettled) {
          isSettled = true;
          clearTimeout(timer);
          resolve(result);
        }
      })
      .catch((err: Error) => {
        if (!isSettled) {
          isSettled = true;
          clearTimeout(timer);
          reject(err);
        }
      });
  });
}

=== 总结 ===

对于问题"能否杀死超时的 Promise"：

1. 纯 Promise 层面：不能，Promise 一旦创建就会执行到底
2. 网络请求层面：可以使用 AbortController
3. 计算任务层面：可以使用 TaskPool 的 cancel 功能
4. 业务逻辑层面：可以通过标志位忽略超时后的结果

最接近 Java 线程池 .get(timeout) 行为的方案是使用 TaskPool