JS如何实现Promise调度？Promise的执行顺序-js教程-PHP中文网

promise调度的核心在于微任务队列的高优先级，即promise的then、catch、finally回调被放入微任务队列，在当前宏任务结束后立即执行，因此比settimeout等宏任务更早执行；promise构造函数内的同步代码会立即执行，而其回调通过事件循环机制在微任务阶段处理，确保异步操作的有序性和及时性；链式调用通过.then返回新promise实现顺序执行，每个回调在前一个promise解决后被推入微任务队列；并行执行如promise.all、promise.race等则让多个promise同时开始，待条件满足后将聚合结果的回调推入微任务队列；async/await是基于promise的语法糖，await暂停函数执行并将后续逻辑作为微任务注册，恢复时继续执行，但连续await独立异步操作会导致串行化性能问题，需通过先启动所有promise再await结果来优化；顶层await仅在支持的模块环境中可用，理解其底层调度机制有助于避免陷阱并提升异步代码的可读性与效率。

JS如何实现Promise调度？Promise的执行顺序

Promise调度在JavaScript中，简单来说，就是一套关于如何以及何时执行异步操作回调的规则，它的核心在于JavaScript事件循环中“微任务队列”（Microtask Queue）的优先级机制。Promise的执行顺序，概括起来是：Promise本身（构造函数内的同步代码）会立即执行；而其

.then()

登录后复制

.catch()

登录后复制

.finally()

登录后复制

等回调，则会被放入微任务队列，等待当前宏任务（如主脚本执行）完成后，立即、批量地执行。这赋予了Promise回调比

setTimeout

登录后复制

等宏任务更高的优先级。

JS如何实现Promise调度？Promise的执行顺序

要理解Promise的调度，我们得深入到JavaScript的“心脏”——事件循环（Event Loop）。我常常觉得，这个概念是理解JS异步编程的基石，也是Promise能如此“魔幻”地处理异步的秘密。

当一个Promise被创建时，其构造函数内部的代码是同步执行的。比如：

console.log('开始');
new Promise(resolve => {
    console.log('Promise构造函数内部');
    resolve();
});
console.log('结束');
// 输出：
// 开始
// Promise构造函数内部
// 结束

登录后复制

这很直接，对吧？但一旦涉及到

.then()

登录后复制

.catch()

登录后复制

.finally()

登录后复制

，事情就变得有点意思了。这些方法注册的回调函数，不会立即执行，它们会被“排队”到微任务队列里。而微任务队列的优先级非常高，它会在当前正在执行的宏任务（比如整个脚本的执行、一个

setTimeout

登录后复制

的回调、一个用户事件处理）结束后，但在浏览器渲染或执行下一个宏任务之前，被清空。

这就像是，你手里有一堆待办事项（宏任务），但突然来了几个“紧急”的小任务（微任务），你必须先把这些紧急的小任务处理完，才能继续你的大任务，或者开始下一个大任务。Promise的回调就是这些“紧急”的小任务。

为什么Promise回调比setTimeout更早执行？

这是个经典问题，也是理解Promise调度机制的关键点。我刚接触Promise的时候，也曾被这个“反直觉”的现象困扰过。

答案就藏在JavaScript的事件循环机制里。简单来说，事件循环不断地检查两类任务队列：宏任务队列（Macrotask Queue）和微任务队列（Microtask Queue）。

宏任务（Macrotasks）：包括像
```
setTimeout
```
登录后复制
,
```
setInterval
```
登录后复制
, I/O操作（如网络请求完成），用户交互事件（点击、键盘输入），以及整个脚本的执行本身。每次事件循环迭代，只会从宏任务队列中取出一个任务来执行。
微任务（Microtasks）：主要包括Promise的回调（
```
.then()
```
登录后复制
,
```
.catch()
```
登录后复制
,
```
.finally()
```
登录后复制
），
```
MutationObserver
```
登录后复制
的回调，以及
```
queueMicrotask
```
登录后复制
等。

关键点在于：在每次宏任务执行完毕之后，事件循环会立即清空所有的微任务队列，然后再去宏任务队列中取下一个宏任务。

所以，当你写下这样的代码时：

console.log('1');

setTimeout(() => {
    console.log('2');
}, 0);

Promise.resolve().then(() => {
    console.log('3');
});

console.log('4');

登录后复制

执行顺序是这样的：

```
console.log('1')
```
登录后复制
同步执行。
```
setTimeout
```
登录后复制
的回调被放入宏任务队列。
```
Promise.resolve().then()
```
登录后复制
的回调被放入微任务队列。
```
console.log('4')
```
登录后复制
同步执行。
当前宏任务（主脚本）执行完毕。
事件循环检查微任务队列，发现
```
console.log('3')
```
登录后复制
，立即执行。
微任务队列清空。
事件循环检查宏任务队列，发现
```
console.log('2')
```
登录后复制
，执行。

最终输出：

1 -> 4 -> 3 -> 2

登录后复制

。

这种优先级设计，在我看来，是Promise能够保证其回调“尽快”执行，并且在一定程度上保持异步操作“有序”的关键。它让Promise在处理异步流程控制时显得更为强大和可预测。

Promise链式调用与并行执行的调度差异

Promise在实际应用中，往往不会是孤立的一个，它更多地以链式调用或并行组合的形式出现。这两种模式在调度上，虽然都遵循微任务的规则，但在逻辑流程和性能考量上，有着明显的差异。

链式调用 (

.then().then()...

登录后复制

)

链式调用是Promise最常见的用法之一，它允许我们将一系列异步操作按顺序串联起来。比如：

function step1() {
    console.log('Step 1 开始');
    return new Promise(resolve => setTimeout(() => {
        console.log('Step 1 完成');
        resolve('数据A');
    }, 100));
}

function step2(data) {
    console.log('Step 2 接收到:', data);
    return new Promise(resolve => setTimeout(() => {
        console.log('Step 2 完成');
        resolve('数据B');
    }, 50));
}

console.log('主流程开始');
step1()
    .then(resultA => {
        console.log('Promise链：进入第一个then');
        return step2(resultA); // 返回一个新的Promise
    })
    .then(resultB => {
        console.log('Promise链：进入第二个then，最终结果:', resultB);
    })
    .catch(error => {
        console.error('Promise链：发生错误:', error);
    });
console.log('主流程结束');

登录后复制

在这个例子中：

```
step1()
```
登录后复制
被调用，其内部的
```
setTimeout
```
登录后复制
被放入宏任务队列。
```
step1()
```
登录后复制
返回的Promise对象被
```
.then()
```
登录后复制
监听。
当
```
step1
```
登录后复制
内部的
```
setTimeout
```
登录后复制
执行完毕，
```
resolve('数据A')
```
登录后复制
被调用，
```
step1
```
登录后复制
返回的Promise状态变为fulfilled。
此时，
```
step1().then(...)
```
登录后复制
的回调被放入微任务队列。
事件循环清空微任务队列，执行第一个
```
.then()
```
登录后复制
的回调，其中又调用了
```
step2()
```
登录后复制
。
```
step2()
```
登录后复制
返回的Promise对象被后续的
```
.then()
```
登录后复制
监听。
当
```
step2
```
登录后复制
内部的
```
setTimeout
```
登录后复制
执行完毕，
```
resolve('数据B')
```
登录后复制
被调用，
```
step2
```
登录后复制
返回的Promise状态变为fulfilled。
此时，第二个
```
.then()
```
登录后复制
的回调被放入微任务队列。
事件循环清空微任务队列，执行第二个
```
.then()
```
登录后复制
的回调。

链式调用的核心在于，每个

.then()

登录后复制

（或

.catch()

登录后复制

.finally()

登录后复制

）都会返回一个新的Promise，后续的

.then()

登录后复制

是监听这个新Promise的状态。这意味着每个步骤都是在前一个步骤完成后才开始的，保证了严格的顺序性。

行者AI

行者AI绘图创作，唤醒新的灵感，创造更多可能

100

查看详情

并行执行 (

Promise.all()

登录后复制

,
Promise.race()
登录后复制
,
Promise.allSettled()
登录后复制
)

当你有多个相互独立的异步操作，并且你关心它们全部完成（或其中一个完成）的结果时，并行执行就派上用场了。这通常能显著提高效率，因为它不会等待一个操作完成后再开始下一个。

Promise.all(iterable)
登录后复制
: 等待所有Promise都成功（fulfilled）才成功，如果其中任何一个Promise失败（rejected），则立即失败。
Promise.race(iterable)
登录后复制
: 哪个Promise最先成功或失败，就以那个Promise的结果为准。
Promise.allSettled(iterable)
登录后复制
: 等待所有Promise都“落定”（settled，即无论是成功还是失败），然后返回一个包含每个Promise结果（状态和值）的数组。

以

Promise.all()

登录后复制

为例：

function fetchUser() {
    return new Promise(resolve => setTimeout(() => {
        console.log('Fetched user');
        resolve({ id: 1, name: 'Alice' });
    }, 200));
}

function fetchPosts() {
    return new Promise(resolve => setTimeout(() => {
        console.log('Fetched posts');
        resolve([{ id: 101, title: 'Post A' }]);
    }, 100));
}

console.log('开始并行获取数据');
Promise.all([fetchUser(), fetchPosts()])
    .then(results => {
        console.log('所有数据获取完成:', results);
    })
    .catch(error => {
        console.error('并行获取数据失败:', error);
    });
console.log('并行获取指令已发出');

登录后复制

这里，

fetchUser()

登录后复制

和

fetchPosts()

登录后复制

会几乎同时开始执行（在它们被调用的那一刻）。它们的内部

setTimeout

登录后复制

会各自进入宏任务队列。当它们各自的Promise被resolve后，

Promise.all()

登录后复制

的

.then()

登录后复制

回调才会被放入微任务队列。

调度差异总结：

链式调用：严格按序执行，前一个Promise解决后，其
```
.then
```
登录后复制
回调进入微任务队列，执行完毕后才可能触发下一个Promise的开始。
并行执行：所有Promise几乎同时开始执行，它们各自的完成状态会独立地被
```
Promise.all
```
登录后复制
/
```
race
```
登录后复制
/
```
allSettled
```
登录后复制
聚合，只有当聚合条件满足时，聚合Promise的
```
.then
```
登录后复制
回调才会被放入微任务队列。

理解这两种模式的调度差异，对于优化异步操作的性能和逻辑流程至关重要。

async/await在Promise调度中的角色与陷阱

async/await

登录后复制

是ES2017引入的语法糖，它让异步代码看起来和写同步代码一样，极大地提高了代码的可读性。但需要明确的是，

async/await

登录后复制

并没有改变Promise的底层调度机制，它只是在Promise之上提供了一个更优雅的语法封装。

async/await

登录后复制

的角色：

一个

async

登录后复制

函数总是返回一个Promise。当你在

async

登录后复制

函数内部使用

await

登录后复制

关键字时，它会“暂停”当前

async

登录后复制

函数的执行，直到它等待的Promise解决（fulfilled或rejected）。一旦该Promise解决，

async

登录后复制

函数会从暂停的地方继续执行。

这个“暂停”和“恢复”的过程，其实就是巧妙地利用了Promise的微任务调度。当

await promise

登录后复制

时，如果

promise

登录后复制

还没有解决，那么

async

登录后复制

函数会把剩余的代码作为这个

promise

登录后复制

的

.then()

登录后复制

回调来处理，并将这个

.then()

登录后复制

回调放入微任务队列。

async function fetchData() {
    console.log('fetchData 开始');
    const user = await new Promise(resolve => setTimeout(() => {
        console.log('获取用户数据完成');
        resolve({ name: 'Bob' });
    }, 100));
    console.log('用户数据:', user);

    const posts = await new Promise(resolve => setTimeout(() => {
        console.log('获取文章数据完成');
        resolve([{ title: 'Hello World' }]);
    }, 50));
    console.log('文章数据:', posts);

    return { user, posts };
}

console.log('主脚本开始');
fetchData().then(data => {
    console.log('fetchData 完成并返回:', data);
});
console.log('主脚本结束');

登录后复制

执行流程大致是：

```
console.log('主脚本开始')
```
登录后复制
同步执行。
```
fetchData()
```
登录后复制
被调用，
```
console.log('fetchData 开始')
```
登录后复制
同步执行。
遇到第一个
```
await
```
登录后复制
。
```
new Promise(...)
```
登录后复制
立即执行，其内部的
```
setTimeout
```
登录后复制
放入宏任务队列。
```
fetchData
```
登录后复制
函数在这里“暂停”，它把等待用户数据的剩余部分作为一个微任务，注册到当前Promise的解决回调中。
```
console.log('主脚本结束')
```
登录后复制
同步执行。
当前宏任务（主脚本）执行完毕。
事件循环清空微任务队列（目前没有Promise回调被放入）。
事件循环从宏任务队列中取出第一个
```
setTimeout
```
登录后复制
（获取用户数据）执行。
```
获取用户数据完成
```
登录后复制
打印，用户数据Promise解决。
```
fetchData
```
登录后复制
函数注册的微任务（即
```
await
```
登录后复制
之后的代码）被放入微任务队列。
事件循环清空微任务队列，执行
```
fetchData
```
登录后复制
剩余部分：
```
console.log('用户数据:', user)
```
登录后复制
。
遇到第二个
```
await
```
登录后复制
。
```
new Promise(...)
```
登录后复制
立即执行，其内部的
```
setTimeout
```
登录后复制
放入宏任务队列。
```
fetchData
```
登录后复制
函数再次“暂停”，把等待文章数据的剩余部分作为一个微任务注册。
事件循环从宏任务队列中取出第二个
```
setTimeout
```
登录后复制
（获取文章数据）执行。
```
获取文章数据完成
```
登录后复制
打印，文章数据Promise解决。
```
fetchData
```
登录后复制
函数注册的微任务（即第二个
```
await
```
登录后复制
之后的代码）被放入微任务队列。
事件循环清空微任务队列，执行
```
fetchData
```
登录后复制
剩余部分：
```
console.log('文章数据:', posts)
```
登录后复制
，并最终返回结果。
```
fetchData()
```
登录后复制
返回的Promise解决，其
```
.then()
```
登录后复制
回调被放入微任务队列。
事件循环清空微任务队列，执行
```
console.log('fetchData 完成并返回:', data)
```
登录后复制
。

常见的陷阱：

阻塞非Promise值：
```
await
```
登录后复制
后面跟着的如果不是Promise，它会立即解析，不会产生异步等待。但这本身不是陷阱，只是需要理解其行为。真正的陷阱是误以为
```
await
```
登录后复制
能让所有东西都变异步。
```
async function example() {
    console.log('A');
    await 1; // 立即解析，不等待
    console.log('B');
}
example(); // 输出 A -> B
```
登录后复制

串行化非必要操作：

await

登录后复制

的默认行为是串行等待。如果你有多个独立的异步操作，并且它们之间没有依赖关系，使用连续的

await

登录后复制

会导致它们一个接一个地执行，而不是并行执行，从而降低效率。

async function fetchAllDataInefficiently() {
    const user = await fetchUser(); // 等待 user 完成
    const posts = await fetchPosts(); // 再等待 posts 完成
    return { user, posts };
}

// 正确的做法是并行启动：
async function fetchAllDataEfficiently() {
    const userPromise = fetchUser();
    const postsPromise = fetchPosts();
    const user = await userPromise;
    const posts = await postsPromise;
    return { user, posts };
}

登录后复制

这里，

fetchAllDataEfficiently

登录后复制

利用了

Promise.all

登录后复制

的思想，先启动所有异步操作，再等待它们的结果，这比

fetchAllDataInefficiently

登录后复制

更高效。

顶层
```
await
```
登录后复制
的环境限制： 在一些较新的JavaScript环境中（如ES模块的顶层），你可以直接使用
```
await
```
登录后复制
而不需要将其包裹在
```
async
```
登录后复制
函数中。但在传统的脚本文件或CommonJS模块中，直接使用
```
await
```
登录后复制
会导致语法错误。