一、JS是单线程
由于JS是浏览器脚本语言，主要用途是和用户互动以及操作DOM，这决定了它只能是单线程，否则会带来很复杂的同步问题。
JS是单线程，这个线程中只拥有唯一的一个事件循环。
二、任务队列
单线程意味着，所有的任务需要排队，前一个任务结束，才会执行下一个任务。
但是，如果前一个任务耗时很长，后一个任务就不得不一直等待，有时候会遇见这样的问题，很多时候CPU空闲，但是由于IO设备（输入输出设备）很慢，比如AJAX操作从网络中读取数据，但是这时主线程完全可以不管IO设备，挂起处于等待的任务，先运行排在后面的任务，等到IO设备返回了结果，再把挂起的任务继续执行。
所以，任务可以分成两种，一种是同步任务，另一种是异步任务。
同步任务指的是，在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；异步任务指的是，不进入主线程、而进入"任务队列"（task queue）的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。
事件循环的步骤：
（1）所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。
（2）主线程之外，还存在一个"任务队列"（task queue）。只要异步任务有了运行结果，就在"任务队列"之中放置一个事件。
（3）一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行栈，开始执行。
（4）主线程不断重复上面的第三步。
三、关于事件循环和任务队列的规则
- 一个线程中，事件循环是唯一的，但是任务队列可以有多个;
- 任务队列又分为macro-task（宏任务）和micro-task（微任务）;
- macro-task大概包括：script（整体代码）,setTimeout,setInterval,setImmediate,I/O,UI rendering;
- micro-task大概包括：process.nextTick,Promise,Object.observe(已废弃),MutationObserver(html5新特性)
- setTimeout/Promise等我们称之为任务源。而进入任务队列的是他们指定的具体执行任务。
- 来自不同任务源的任务会进入到不同的任务队列
- 事件循环的顺序，决定了JavaScript代码的执行顺序。它从script(整体代码)开始第一次循环。之后全局上下文进入函数调用栈。直到调用栈清空(只剩全局)，然后执行所有的micro-task。当所有可执行的micro-task执行完毕之后。循环再次从macro-task开始，找到其中一个任务队列执行完毕，然后再执行所有的micro-task，这样一直循环下去。
- 其中每一个任务的执行，无论是macro-task还是micro-task，都是借助函数调用栈来完成
setTimeout作为一个任务分发器，这个函数会立即执行，而它所要分发的任务，也就是它的第一个参数，才是延迟执行。
四、结合实例理解JS事件循环机制
/**
* example one
*
* 一开始，只有script（整体代码），分发到macro-task队列
* setTimeout函数：宏任务源，分发到对应的macro-task队列
* Promise实例：构造函数中的第一个参数是在new时执行的，不会进入其他队列
* .then被分发到micro-task的Promise队列中
*script任务继续往下执行，输出global1，然后，全局任务执行完毕
*
* 第一个宏任务script执行完毕之后，就开始执行所有的可执行的微任务
* 这时候，微任务中，只有Promise队列中的任务then1，执行输出
*
* 当所有的微任务执行完毕后，第一轮循环结束，第二轮循环开始，第二轮循环仍然从宏任务macro-task开始
*
* 宏任务中，只有在setTimeout队列中还有一个timeout1的任务等待执行。因此就直接执行即可
*
* 结果：
* promise1 =》 promise2 =》 global1 =》 then1 =》 timeout1
*/
setTimeout(function() {
console.log('timeout1');
});
new Promise(function(resolve) {
console.log('promise1');
for(let i = 0; i < 1000; i++) {
i === 99 && resolve();
}
console.log('promise2');
}).then(function() {
console.log('then1');
});
console.log('global1');
/**
* 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')
})
});
