JS事件循环宏任务微任务 | 设计模式

在实际开发中，JS事件循环机制中宏任务和微任务的执行顺序是关键，我见过很多项目在异步处理中因为没搞清楚这点，导致界面卡顿或者状态更新混乱。比如在Node.js中使用async/await时，如果在await后没有正确处理Promise的resolve，容易误以为是同步执行，但实际上并不会阻塞主线程。这一问题在前端用setTimeout或者setInterval时也经常出现，它会把回调放到宏任务队列中，而微任务队列中的Promise.then或者MutationObserver会优先执行。在实际场景中，比如渲染DOM后执行一些数据更新，如果直接在回调中操作，可能会在DOM还没渲染完成时就触发下一个任务，进而导致渲染延迟或者布局抖动。

我曾经在使用requestAnimationFrame时遇到问题，由于它是在浏览器的渲染循环中插入的，换句话说，它属于宏任务，但执行时机更精准。这时候如果在其中插入Promise.then，它会立刻插入到微任务队列，导致宏任务被推迟。我见过一个游戏项目因为误用requestAnimationFrame配合微任务导致帧率严重下降，甚至出现画面撕裂。这种情况下，必须明确区分任务类型，并在微任务中做状态更新，而将渲染逻辑交给宏任务。另外，对于Node.js中使用child_process.spawn创建的子进程，它的回调属于宏任务，如果在其中需要立即处理数据，应该用setImmediate或者process.nextTick来触发微任务，避免阻塞主流程。

在Node.js中，process.nextTick是微任务的最原始实现，它在事件循环的每个阶段开始时执行。我曾经在处理大量数据时误用它，导致堆内存溢出。原因是process.nextTick的回调会立即执行，而不是排队，所以如果连续调用它，会形成一个“微任务队列”，最终造成主流程无法处理其他任务，甚至崩溃。此时应该用setImmediate来包装，因为它属于宏任务，能避免这种情况。在前端用Vue或React时，如果在nextTick中进行大量DOM操作，同样容易出现性能问题，必须控制好调用频率。

在使用async/await时，要特别注意Promise的执行顺序。比如，在一个函数中await一个Promise，其实它并不会阻塞事件循环，而是将后续代码放到微任务队列中，等待Promise resolve。这常被用来优化异步逻辑，让代码看起来更线性。但反过来，如果在await中嵌套了多个Promise，它们的执行顺序可能会出错，尤其是在Promise链中没有正确处理错误。我曾经在处理API请求时，误将多个then嵌套起来，导致错误无法被捕获，最终只能通过try/catch来避免。例如：

```js
async function fetchData() {
try {
const data1 = await fetch('/api/1');
const data2 = await fetch('/api/2');
return [data1, data2];
} catch (error) {
console.error('Error fetching data:', error);
}
}
```

这段代码中，data1和data2的fetch都属于微任务，它们的执行顺序取决于各自的Promise resolve时间，但因为都是微任务，所以一定会在当前宏任务结束后按顺序执行。这在处理依赖关系时非常重要，比如依赖data1才能处理data2，这时候顺序就很重要。

在浏览器中，微任务队列通常通过MutationObserver来保持活跃状态，如果页面没有触发任何DOM变更，队列就无法清空，导致事件循环无法继续。我见过一个前端项目在卸载组件时没有正确清理MutationObserver，结果页面关闭后依然在后台执行微任务，占用CPU资源。这种情况在使用Vue或React的组件卸载钩子时尤其常见，必须在beforeDestroy或useEffect中手动移除观察者。例如，在Vue中：

```js
beforeDestroy() {
if (this.observer) {
this.observer.disconnect();
}
}
```

类似的，在React中，useEffect返回的清理函数也应该处理这些观察者。这不仅关系到性能，还可能影响后续任务的调度，尤其是在页面长时间空闲时，容易触发不必要的刷新。

在Node.js中，使用setImmediate可以确保回调在当前宏任务结束后执行，但它的执行时机取决于事件循环阶段。我曾经在处理文件读写时错误地使用setImmediate来等待异步操作完成，导致数据读取被多次触发，最终造成文件句柄泄露。正确的方式是使用Promise链或者异步函数，例如：

```js
const fs = require('fs').promises;
async function readData() {
const data = await fs.readFile('file.txt', 'utf8');
console.log(data);
}
```

这种方式不仅能避免资源泄露，还能让代码更清晰。另外，在Node.js中，如果使用async/await，并且希望在操作完成后立即执行某些逻辑，应该将这些逻辑放在then中，而不是直接写在await后面。例如：

```js
fetchData().then(data => {
console.log(data);
});
```

这样可以确保后续代码不会立即执行，而是等到Promise resolve后才进行，避免了潜在的执行顺序问题。

在处理微任务时，需要注意其执行时机和队列的累积。比如，在使用Promise.then时，如果多个Promise同时resolve，它们会按照顺序被处理，而不是并行。这在处理多个异步请求时容易被忽略，比如使用Promise.all来等待所有请求完成。如果请求数量庞大，可能会导致内存占用过高，甚至出现栈溢出。我曾经在处理用户上传文件列表时，误用Promise.all导致内存暴涨，最终只能通过限制并发数量或者分批处理来解决。例如：

```js
const batch = 5;
const promises = [];
for (let i = 0; i < files.length; i += batch) {
const batchPromises = files.slice(i, i + batch).map(file => uploadFile(file));
await Promise.all(batchPromises);
}
```

这种方式能有效减少内存压力，同时保证微任务的执行顺序。此外，在浏览器中，微任务的执行会受到浏览器的限制，比如在页面关闭时，微任务队列会被清空，因此不要在页面关闭后执行长时间的微任务操作。

在使用requestIdleCallback时，它会将回调放入微任务队列，并在浏览器空闲时执行。这在优化页面性能时非常有用，但必须注意它的执行时机，因为它只会在浏览器空闲时触发，而不是保证立即执行。我曾经在页面加载时使用requestIdleCallback来执行初始化操作，结果用户在页面打开后立即进行交互，导致初始化操作被延迟到下一个空闲周期，引发体验问题。正确的方法是将初始化操作放在微任务队列，或者使用setTimeout配合setImmediate，确保任务在页面加载后尽快执行。

对于性能影响来说，微任务通常比宏任务快，因为它会在当前宏任务结束后立即处理，而不会等待下一帧。这在处理DOM更新、状态变更等操作时非常关键。比如，在React中，setState触发的更新是微任务，因此在渲染完成后，状态变更会立即生效。但过多的微任务也可能导致性能下降，因为它们会连续执行，占用过多CPU时间。我见过一个项目中使用了大量的Promise.then，导致页面卡顿，最终只能通过调整代码结构或者引入任务队列来优化。

在使用Node.js的process.nextTick时，要特别小心其执行时机。它会在当前事件循环阶段结束后立即执行，而不是等到下一个阶段。这意味着它可以比setImmediate更快执行，但也更容易造成“微任务队列”的堆积。我曾经在处理大量数据时，错误地使用nextTick导致CPU使用率达到100%，最终只能通过将nextTick改为setImmediate来避免。此外，在前端中，MutationObserver和PerformanceObserver也属于微任务，它们的执行时机会影响页面性能，尤其是在高频率触发时。

在某些情况下，可以使用多个微任务队列来优化执行顺序。比如，在Vue中，当使用$nextTick时，它会将回调放入微任务队列，并在DOM更新后执行。这在处理DOM操作时非常有用，但如果在$nextTick中再次调用$nextTick，可能会形成嵌套的微任务队列，造成执行顺序混乱。我见过一个项目中因为错误使用$nextTick导致页面状态无法正确同步，最终只能通过手动管理微任务队列来解决。

在使用Node.js的某些模块时，比如cluster模块，它会利用child_process.spawn来创建子进程。如果在子进程的回调中使用nextTick，可能会导致主流程被阻塞。正确的做法是使用setImmediate来确保回调不会影响主流程。例如：

```js
const child = child_process.spawn('node', ['child.js']);
child.on('close', () => {
setImmediate(() => {
console.log('Child process closed');
});
});
```

这种方式能有效避免资源竞争和执行阻塞。此外，在使用像event-loop-async-parallel这样的第三方模块时，可以更灵活地控制任务的执行顺序，避免微任务队列的拥堵。

在浏览器中，可以通过Performance API来监控微任务和宏任务的执行时间。比如，使用performance.now()来测量某个Promise.then的执行时间，或者使用performance.mark来记录任务开始和结束时间。这种方式能帮助开发者理解任务调度的实际情况，从而优化代码。例如：

```js
performance.mark('start');
fetch('https://api.example.com/data').then(() => {
performance.mark('end');
console.log(performance.measure('measure1'), 'Microtask executed');
});
```

这不仅能帮助排查性能问题，还能在调试时快速定位任务执行的瓶颈。不过，这种方式并不适合所有场景，尤其是在需要精确控制任务执行时间时，可能会造成额外的开销。

在Node.js中，如果需要在事件循环的下一个阶段执行任务，可以使用setImmediate。它比setTimeout更快，但执行时机取决于事件循环的阶段。我曾经在处理文件I/O时误用setTimeout，结果导致任务被延迟到下一次事件循环，进而影响了整体流程。正确的做法是使用setImmediate来确保任务在当前阶段结束后立即执行，比如：

```js
fs.readFile('file.txt', 'utf8', (err, data) => {
setImmediate(() => {
console.log(data);
});
});
```

这种方式能有效避免延迟，同时不会占用过多CPU资源。此外，在使用像async/await和Promise链时，也要注意它们的执行顺序，避免不必要的资源竞争。

在处理微任务时，要特别注意其执行时的上下文。比如，在Promise.then中，this的指向可能发生变化，导致逻辑错误。我曾经在React组件中使用Promise.then来处理数据更新，结果this的指向错误，导致状态无法正确绑定。正确的做法是使用箭头函数或者显式绑定上下文，例如：

```js
fetchData().then(data => this.setState({ data }));
```

或者：

```js
fetchData().then(data => {
this.setState({ data });
}.bind(this));
```

这种问题在使用闭包时尤为常见，必须通过绑定上下文或者使用箭头函数来避免。

在使用某些浏览器API时，比如IntersectionObserver，它的回调会自动放入微任务队列，导致执行顺序不可预测。我曾经在处理图片懒加载时，错误地期望回调立即执行，结果发现图片加载会被延迟到下一个宏任务。正确的做法是结合requestAnimationFrame或setTimeout来确保回调在合适的时间执行，而不是依赖微任务队列。例如：

```js
const observer = new IntersectionObserver(entries => {
if (entries[0].isIntersecting) {
setImmediate(() => {
// 加载图片逻辑
});
}
});
```

这种方式能确保图片加载在浏览器空闲时进行，同时不影响其他任务的执行顺序。

在Node.js中，如果需要在事件循环的下一个阶段执行任务，可以使用setImmediate。它比setTimeout更快，但执行时机取决于事件循环的阶段。我曾经在处理文件I/O时误用setTimeout，结果导致任务被延迟到下一次事件循环，进而影响了整体流程。正确的做法是使用setImmediate来确保任务在当前阶段结束后立即执行，比如：

```js
fs.readFile('file.txt', 'utf8', (err, data) => {
setImmediate(() => {
console.log(data);
});
});
```

这种方式能有效避免延迟，同时不会占用过多CPU资源。此外，在使用像async/await和Promise链时，也要注意它们的执行顺序，避免不必要的资源竞争。