setTimeout async promise执行顺序总结

下面先看一道面试中经常被问的题

        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')
    })
});