任何时候，只要把一段代码包装成一个函数，并指定它在响应某个事件（定时器、鼠标点击、Ajax响应等）时执行，你就是在代码中创建了一个将来执行的块，也由此在这个程序中引入了异步机制。

1.2 事件循环

直到ES6，JS才真正内建有直接的异步概念。

一定要清楚，setTimeout()并没有把回调函数挂在事件循环队列中。它所做的是设定一个定时器，当定时器到时后，环境会把你的回调函数放在事件循环中，在未来某个时刻的tick会摘下并执行这个回调。

1.3 并行线程

“异步”和“并行”常常被混为一谈，异步是关于现在和将来的时间间隙，而并行是关于能够同时发生的事情。

并行计算最常见的工具就是进程和线程。进程和线程独立运行，并可能同时运行：在不同的处理器，甚至不同的计算机上，但多个线程能够共享单个进程的内存。

1.4.2 交互

协调交互顺序来处理竟态条件bug。

var a, b;
function foo(x){
    a = x * 2;
    baz();
}
function bar(y){
    b = y * 2;
    baz();
}

function baz(){
    console.log(a + b);
}
// ajax() 是某个库中的某个Ajax函数
ajax( 'http://some.url.1', foo );
ajax( 'http://some.url.2', bar );

这个例子中无论foo() 和 bar() 哪一个先被触发，总会使baz() 过早运行; 但对baz()的第二次调用就没有问题，因为这时候a 和 b 都已经可用了。

要解决这个问题有多种方法，这里给出一种简单方法：

var a, b;
function foo(x) {
    a = x * 2;
    if(a && b){
        baz();
    }
}
function bar(y){
    b = y * 2;
    if(a && b){
        baz();
    }
}
function baz(){
    console.log( a + b);
}

包裹baz()调用的条件判断if(a && b) 传统上称为门 （gate），虽不能确定a和b到达的顺序，但是会等到它们两个都准备好再进一步打开门。

另一种可能遇到的并发交互条件有时称为竟态（race），但是更精确的叫法是门闩（latch）。它的特性可描述为“只有第一名取胜”，在这里，不确定性是可接受的，因为它明确指出了这一点是可接受的：需要“竞争”到终点，且只有唯一的胜利者。

var a;
function foo(x){
    a = x * 2;
    baz();
}
function bar(x){
    a = x / 2;
    baz();
}
function baz() {
    console.log(a);
}
ajax('http://some.url.1', foo);
ajax('http://some.url.2', bar);

不管哪个后被触发，都可能重复调用baz()。所以，可通过一个简单的门闩协调这个交互过程，只让第一个通过：

var a;
function foo(x){
    if(!a){
        a = x * 2;
        baz();
    }
}
function baz(x){
    if(!a){
        a = x / 2;
        baz();
    }
}
function baz(){
    console.log( a ); 
}

ajax('http://some.url.1', foo);
ajax('http://some.url.2', bar);

1.4.3 协作

还有一种并发合作方式，称为并发协作。这里重点不再是通过共享作用域中的值进行交互。这里的目标是取到一个长期运行的“进程”，并将其分割成多个步骤或多批任务，使得其他并发“进程”有机会将自己的运算插入到事件循环队列中交替运行。

举例：考虑一个需要遍历很长的结果列表进行值转换的Ajax响应处理函数。

var res = [];
// response(..) 从Ajax调用中取得结果数组
function response(data){
    // 添加到已有的res数组
    res = res.concat(
        // 创建一个新的变换数组把所有data值加倍
        data.map( function(val){
            return val * 2;
        });
    );
}

// ajax(..) 是某个库中提供的某个ajax函数
ajax('http://some.url.1', response );
ajax('http://some.url.2', response );

如果 url.1 有几万条记录的话，就可能需要运行相当一段时间了。这样的“进程”运行时，页面上的其他代码都不能运行，包括不能有其他的response(..)调用或UI刷新，甚至是像滚动、输入、按钮事件。

所以，可异步地批处理这些结果。

var res = [];

function response(data){
    // 一次批处理1000个    
    var chunk = data.splice( 0, 1000 );
    // 添加到已有的res组
    res = res.concat(
        // 创建一个新的数组把chunk中所有值加倍
        chunk.map(function(val){
            return val * 2;
        })
    );
    // 还有剩下的需要处理吗？
    if(data.length > 0){
        // 异步调度下一次批处理
        setTimeout(function(){
            response( data );
        }, 0)
    }
    
}

这里使用setTimeout(..0)进行异步调度，基本上它是意思就是“把这个函数插入到当前事件循环队列的结尾处”。

1.5 任务
事件循环队列类似于一个游乐园：玩过一个游戏后，你需要重新排队。而任务队列类似于插队接着玩。