Promise、 Async/await 、setTimeOut执行顺序及区别

最终结果：

 setTimeout属性宏任务，Promise里面的then方法属于微任务，Async/Await中await语法后面紧跟的表达式是同步的，但接下来的代码是异步的，属于微任务。

---

原因分析：

1、  js是单线程所有主线程的同步任务先执行，然后执行微任务队列的程序，最后执行宏任务队列，秉承先进先出的原则。包括同步任务、异步任务，异步任务又包括宏观任务和微观任务

2、执行顺序：同步任务——>微观任务——>宏观任务

3、宏任务（macrotask)的方法有：script(整体代码)、setTimeout、setInterval、I/O、UI交互事件、postMessage、MessageChannel、setImmediate(Node.js 环境)

 宏任务（macrotask）：主代码块 > setImmediate > MessageChannel > setTimeout / setInterval

4、微任务(microtask)的方法有：Promise.then、MutaionObserver、process.nextTick(Node.js 环境)，async/await实际上是promise+generator的语法糖，也就是promise，也就是微观任务

微任务（microtask）：process.nextTick > Promise = MutationObserver

---

代码案例：

整个代码的执行流程是： setTimeout推到宏任务队列 然后遇到promise立刻执行，输出2
遇到promise.then推到微任务队列。继续往下，输出4
至此，当前主线程中的同步任务执行完毕，
读取微任务队列中的promise.then，输出3 
浏览器渲染之后继续执行宏任务setTimeout，输出1

区别：

1.setTimeout

console.log('script start') //1. 打印 script start
setTimeout(function(){
    console.log('settimeout')   // 4. 打印 settimeout
})  // 2. 调用 setTimeout 函数，并定义其完成后执行的回调函数
console.log('script end')   //3. 打印 script start
// 输出顺序：script start->script end->settimeou

2.Promise

console.log('script start')
let promise1 = new Promise(function (resolve) {
    console.log('promise1')
    resolve()
    console.log('promise1 end')
}).then(function () {
    console.log('promise2')
})
setTimeout(function(){
    console.log('settimeout')
})
console.log('script end')
// 输出顺序: script start->promise1->promise1 end->script end->promise2->settimeout

3.async/await

async function async1(){
   console.log('async1 start');
    await async2();
    console.log('async1 end')
}
async function async2(){
    console.log('async2')
}
 
console.log('script start');
async1();
console.log('script end')
 
// 输出顺序：script start->async1 start->async2->script end->async1 end

4.执行区别

async function async1() {
    console.log('async1 start');
    await async2();
    console.log('async1 end');
}
async function async2() {
    console.log('async2');
}
 
console.log('start');
setTimeout(() => {
    console.log('setTimeout');
}, 0);
async1();
new Promise(resolve => {
    console.log('promise1');
    resolve();
}).then(() => {
    console.log('promise2');
})
console.log('end');

输出： 
start
async1 start
async2
promise1

end

async1 end
promise2
setTimeout

分析整个过程：

调用顺序问题解析：
async 会定义一个返回 AsyncFunction 对象的异步函数。

即以 async 声明的函数，会隐式地返回一个 Promise 对象。当这个 async 函数返回一个值时，Promise 的 resolve 方法会负责传递这个值；当 async 函数抛出异常时，Promise 的 reject 方法也会传递这个异常值。
await 操作符用于等待一个 Promise 对象。它返回 Promise 对象的处理结果。如果等待的不是 Promise 对象，则返回该值本身。

注意：
await 只能在异步函数 async function 中使用。
如果你希望并行等待两个或者是更多的 Promise 对象，你必须使用Promise.then，而不是await。

队列任务优先级：promise.Trick() > promise的回调 > setTimeout > setImmediate

上述代码可以理解成：

在同步执行阶段：

async1执行到await async2()时，sync2()返回一个Promise,
 其resolve放入到回调队列中，跳出async1，执行new promise的resolve时
，该resolve也会被放入回调队列中。然后执行到console.log('end');，此时同步执行结束。

重点（执行回调队列）：

此时async2()返回的 Promise的resolve会被执行，即执行await async2()，
此时await的Promise的resolve会被放入到新回调队列。
此时原回调队列中new promise的resolve会被执行，
promise2字符被打印，原回调队列执行完毕。

执行新回调队列：

await的Promise的resolve被执行，console.log('async1 end')执行。
async1()返回的Promise的resolve会被放入到新回调队列。

所有回调队列执行完毕，setTimeout执行。