下面先看一道面试中经常被问的题
async function async1() {
console.log("async1 start");
await async2();
console.log("async1 end");
}
async function async2() {
console.log( 'async2');
}
console.log("script start");
setTimeout(function () {
console.log("settimeout");
},0);
async1();
new Promise(function (resolve) {
console.log("promise1");
resolve();
}).then(function () {
console.log("promise2");
});
console.log('script end');
script start
async1 start
async2
promise1
script end
async1 end
promise2
settimeout
await async2();//执行这一句后，输出async2后，await会让出当前线程，将后面的代码加到任务队列中，然后继续执行test()函数后面的同步代码
这类的执行结果可以用一句话总结，先执行同步代码，遇到异步代码就先加入队列，然后按入队的顺序执行异步代码，最后执行setTimeout队列的代码。
补充一下队列任务优先级：promise.Trick()>promise的回调>setTimeout>setImmediate
/**
* example two
*
* 宏任务script首先执行，全局入栈，glob1输出
* setTimeout：分发到对应的宏任务队列
* setImmediate：分发到排列在setTimeout后面的宏任务队列
* process.nextTick: 分发到process.nextTick微任务队列
* Promise：构造函数直接执行，输出glob1_promise
* then分发到Promise相关微任务队列
* setTimeout（第二个）：分发到setTimeout相关任务队列，排在setTimeout1后面
* process.nextTick（第二个）：分发到process.nextTick相关微任务队列，排在第一个process.nextTick后面
* Promise（第二个）：构造函数直接执行，输出glob2_promise
* then分发到Promise相关微任务队列（第一个后面）
* setImmediate（第二个）：分发到排列在setImmediate（第一个后面）的相关宏任务队列
*
* script执行完毕
*
* 执行所有的微任务队列中的任务，所有可执行的微任务执行完毕之后，这一轮循环结束
* 微队列依次输出：process.nextTick微队列：glob1_nextTick =》 glob2_nextTick
* Promise微队列：glob1_then =》 glob2_then
*
* 微任务执行完毕，循环结束，从宏队列开始
* 执行setTimeout（先入队），借助函数调用栈来完成，并且遇到任务分发器的时候也会将任务分发到对应的队列中去。
*
* setTimeout宏队列（两个任务都要执行，setTimeout1先执行，setTimeout2后执行）：
* setTimeout（第一个）：执行timeout1
* process.nextTick分发到process.nextTick相关微队列
* Promise构造函数直接执行：timeout1_promise
* then分发到Promise相关微队列
* setTimeout（第二个）：执行timeout2
* process.nextTick分发到process.nextTick相关微队列
* Promise构造函数直接执行：timeout1_promise
* then分发到Promise相关微队列
*
* setTimeout宏队列执行输出顺序：
* 函数调用栈输出：timeout1 =》timeout1_promise =》timeout2 =》timeout2_promise
* 微队列执行：process.nextTick微队列：timeout1_nextTick =》timeout2_nextTick
* Promise微队列：timeout1_then =》timeout2_then
*
* 循环结束，新一轮循环开始
* setImmediate宏队列（两个任务都要执行，setImmediate1先执行，setImmediate2后执行）：
* setImmediate（第一个）：执行immediate1
* process.nextTick分发到process.nextTick相关微队列
* Promise构造函数直接执行：immediate1_promise
* then分发到Promise相关微队列
* setImmediate（第二个）：执行immediate2
* process.nextTick分发到process.nextTick相关微队列
* Promise构造函数直接执行：immediate2_promise
* then分发到Promise相关微队列
*setImmediate宏队列执行输出顺序：
* 函数调用栈输出：immediate1 =》immediate1_promise =》immediate2 =》immediate2_promise
* 微队列执行：process.nextTick微队列：immediate1_nextTick =》immediate2_nextTick
* Promise微队列：immediate1_then =》immediate2_then
*
* 循环完毕，执行完成
* 输出结果：
* golb1 =》glob1_promise =》glob2_promise =》glob1_nextTick =》glob2_nextTick =》glob1_then =》 glob2_then
* =》timeout1 =》timeout1_promise =》timeout2 =》timeout2_promise =》timeout1_nextTick =》timeout2_nextTick
* =》timeout1_then =》timeout2_then =》immediate1 =》immediate1_promise =》immediate2 =》immediate2_promise
* =》immediate1_nextTick =》immediate2_nextTick =》immediate1_then =》immediate2_then
*/
console.log('golb1');
setTimeout(function() {
console.log('timeout1');
process.nextTick(function() {
console.log('timeout1_nextTick');
});
new Promise(function(resolve) {
console.log('timeout1_promise');
resolve();
}).then(function() {
console.log('timeout1_then')
})
});
setImmediate(function() {
console.log('immediate1');
process.nextTick(function() {
console.log('immediate1_nextTick');
});
new Promise(function(resolve) {
console.log('immediate1_promise');
resolve();
}).then(function() {
console.log('immediate1_then')
})
});
process.nextTick(function() {
console.log('glob1_nextTick');
});
new Promise(function(resolve) {
console.log('glob1_promise');
resolve();
}).then(function() {
console.log('glob1_then')
});
setTimeout(function() {
console.log('timeout2');
process.nextTick(function() {
console.log('timeout2_nextTick');
});
new Promise(function(resolve) {
console.log('timeout2_promise');
resolve();
}).then(function() {
console.log('timeout2_then')
})
});
process.nextTick(function() {
console.log('glob2_nextTick');
});
new Promise(function(resolve) {
console.log('glob2_promise');
resolve();
}).then(function() {
console.log('glob2_then')
});
setImmediate(function() {
console.log('immediate2');
process.nextTick(function() {
console.log('immediate2_nextTick');
});
new Promise(function(resolve) {
console.log('immediate2_promise');
resolve();
}).then(function() {
console.log('immediate2_then')
})
});
