ArkTS中的异步函数（async/await）和Promise的调度模型详解！

菜鸟不学编程

883人浏览 · 2025-08-07 15:50:17

菜鸟不学编程 · 2025-08-07 15:50:17 发布

👋 你好，欢迎来到我的博客！我是【菜鸟不学编程】
我是一个正在奋斗中的职场码农，步入职场多年，正在从“小码农”慢慢成长为有深度、有思考的技术人。在这条不断进阶的路上，我决定记录下自己的学习与成长过程，也希望通过博客结识更多志同道合的朋友。

🛠️ 主要方向包括 Java 基础、Spring 全家桶、数据库优化、项目实战等，也会分享一些踩坑经历与面试复盘，希望能为还在迷茫中的你提供一些参考。
💡 我相信：写作是一种思考的过程，分享是一种进步的方式。

如果你和我一样热爱技术、热爱成长，欢迎关注我，一起交流进步！

全文目录：

前言

随着现代应用程序的复杂性增加，异步编程逐渐成为了开发中不可或缺的一部分。尤其是在移动设备、物联网设备等环境下，异步操作（如网络请求、文件读写、定时器等）能够显著提升应用的响应性和用户体验。在鸿蒙的 ArkTS 中，异步编程同样扮演了非常重要的角色。与传统的同步编程不同，异步编程使得程序在执行耗时操作时可以保持响应，不会阻塞主线程。

本文将详细解析 ArkTS 中异步编程的两大核心机制：async/await 和 Promise，并结合 ArkTS 的调度模型，帮助开发者深入理解异步编程的工作原理和调度机制。

需求分析

1. 异步编程的必要性

在应用开发中，很多操作（例如网络请求、文件读取、数据库查询等）都是耗时的。如果我们在这些操作上采用同步方式编程，程序会阻塞，导致用户体验不佳。因此，异步编程能够有效解决这个问题，让程序在执行耗时操作时仍然能够响应用户输入，保持流畅的用户体验。

2. ArkTS中的异步编程

在 ArkTS 中，异步编程主要依赖于两种机制：async/await 和 Promise。其中，async 和 await 提供了一种更加直观和简洁的异步编程方式，而 Promise 则是异步操作的基础构建块。理解这两者的调度模型对编写高效的异步代码至关重要。

系统架构设计

在 ArkTS 中，异步编程模型是基于 Promise 和 async/await 的。Promise 作为一个表示异步操作结果的对象，它的核心作用是承诺（promise）在未来某一时刻会有一个结果或错误。而 async/await 是基于 Promise 语法糖，它让异步代码的编写更加直观和同步化。

1. Promise调度模型

Promise 是 JavaScript 和 ArkTS 中用于处理异步操作的核心对象。它表示一个异步操作的最终完成（或失败）及其结果值。Promise 对象提供了 .then() 和 .catch() 方法来分别处理操作成功和失败的情况。

Promise的工作流程：

Pending：当 Promise 被创建时，它的状态是 Pending（待定），即异步操作正在进行中。
Resolved：当异步操作成功完成时，Promise 的状态变为 Resolved，并带有一个值作为结果。
Rejected：如果异步操作失败，Promise 的状态变为 Rejected，并带有错误信息。

示例：使用 Promise 处理异步操作

function fetchData(): Promise<string> {
  return new Promise((resolve, reject) => {
    // 模拟网络请求
    setTimeout(() => {
      let success = true; // 假设请求成功
      if (success) {
        resolve("Data fetched successfully");
      } else {
        reject("Data fetch failed");
      }
    }, 1000);
  });
}

fetchData().then((result) => {
  console.log(result);  // 输出：Data fetched successfully
}).catch((error) => {
  console.error(error);  // 输出：Data fetch failed
});

2. async/await的调度模型

async/await 是基于 Promise 的语法糖，它简化了异步代码的编写，避免了回调地狱（callback hell）。async 关键字用于声明一个异步函数，await 关键字用于等待一个 Promise 解决，并获取其返回值。

async函数：返回一个 Promise 对象，即使函数内部没有明确返回 Promise，它也会自动包装为一个 Promise。
await表达式：暂停 async 函数的执行，直到 Promise 解决，并返回 Promise 的结果。

async/await 工作流程：

当执行到 await 时，当前的异步操作会暂停，等待 Promise 返回。
如果 Promise 被解决（Resolved），await 会返回结果并继续执行后续代码。
如果 Promise 被拒绝（Rejected），await 会抛出错误，跳转到 catch 中的异常处理。

示例：使用 async/await 处理异步操作

async function fetchDataAsync(): Promise<string> {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      let success = true;
      if (success) {
        resolve("Data fetched successfully");
      } else {
        reject("Data fetch failed");
      }
    }, 1000);
  });
}

async function runAsyncTask() {
  try {
    const result = await fetchDataAsync();
    console.log(result);  // 输出：Data fetched successfully
  } catch (error) {
    console.error(error);  // 输出：Data fetch failed
  }
}

runAsyncTask();

在上面的例子中，runAsyncTask 是一个异步函数，它通过 await 等待 fetchDataAsync 的结果，并根据结果进行处理。

ArkTS 异步函数调度模型

1. 异步操作的调度顺序

在 ArkTS 中，异步函数的调度机制遵循 事件循环（Event Loop）模型。事件循环是一种处理异步操作的调度机制，它允许事件（如用户输入、网络请求等）异步执行，事件处理的顺序由 JavaScript 引擎决定。具体来说，异步任务（如网络请求、定时器等）会被放入一个 任务队列，当主线程空闲时，任务会从队列中取出并执行。

微任务队列（Microtask Queue）：Promise 的 .then() 和 catch() 方法回调，以及 async/await 中的异步操作，都会被放入微任务队列。微任务的优先级高于宏任务队列。
宏任务队列（Macrotask Queue）：例如，setTimeout、setInterval 等函数的回调会放入宏任务队列。宏任务的优先级低于微任务队列。

当执行到 await 时，当前的 async 函数会暂停执行，直到 Promise 返回结果。在等待过程中，JavaScript 引擎会执行微任务队列中的其他任务，直到主线程空闲，再返回并继续执行后续代码。

2. 事件循环的影响

由于 async/await 本质上依赖于 Promise，它们会进入微任务队列。微任务会在宏任务（如 UI 更新）之前执行，这就确保了在一个事件循环的周期内，异步操作会尽早被处理。

示例：事件循环中的微任务与宏任务

console.log('Start');

setTimeout(() => {
  console.log('Timeout');  // 宏任务
}, 0);

async function asyncFunction() {
  await Promise.resolve();
  console.log('Async Function');  // 微任务
}

asyncFunction();

console.log('End');

输出顺序：

Start
End
Async Function
Timeout

在这个示例中，setTimeout 被放入宏任务队列，而 asyncFunction 中的 await 被放入微任务队列。微任务会在宏任务之前执行，因此输出顺序是先输出 'End' 和 'Async Function'，然后才是 'Timeout'。

性能优化与调度

在异步编程中，特别是涉及到大量异步任务的场景时，性能优化和调度机制是至关重要的。以下是一些优化策略：

1. 减少微任务的积压

当微任务积压过多时，可能导致 UI 渲染和其他宏任务的执行延迟。开发者可以通过将部分异步操作改为宏任务，减少微任务队列中的任务积压。

2. 并行执行异步任务

对于多个独立的异步任务，开发者可以通过 Promise.all 或 Promise.allSettled 等方法并行执行，减少任务的总执行时间。

示例：并行执行多个异步任务

async function fetchData1() {
  return new Promise((resolve) => setTimeout(() => resolve("Data1"), 1000));
}

async function fetchData2() {
  return new Promise((resolve) => setTimeout(() => resolve("Data2"), 2000));
}

async function run() {
  const results = await Promise.all([fetchData1(), fetchData2()]);
  console.log(results);  // 输出：["Data1", "Data2"]
}

run();

通过 Promise.all，fetchData1 和 fetchData2 会并行执行，显著减少总的执行时间。

结语

通过 async/await 和 Promise，ArkTS 提供了强大的异步编程能力，让开发者能够编写高效、可读的异步代码。理解 Promise 的调度模型和 async/await 的工作原理，有助于我们更好地利用异步编程模型，实现高效的任务调度和性能优化。同时，借助事件循环机制，我们可以合理安排异步任务的执行顺序，确保系统的响应性和稳定性。