原文： https://github.com/getify/You-Dont-Know-JS/blob/master/async%20%26%20performance/ch1.md#parallel-threading
译者：熊贤仁
并行线程
人们常常把 “异步” 和 “并行” 这两个术语混淆，但它们其实完全不同。记住，异步是关于 “现在” 和 “将来” 之间的间隙，而并行说的是能够同时发生的事情。
进程和线程是并行计算最常用的工具。进程和线程独立运行，也可能同时运行：在多个独立的处理器上，或者多个独立的计算机上，而多线程可以在同一个进程上共享内存。
相比之下，事件循环将工作分成多个任务，并串行执行它们，不允许对共享内存做并行访问和改变。通过独立线程中的相互协作的事件循环，并行化和 “串行化” 可以共存。
并行线程的交错执行和异步事件的交错执行，其颗粒度是完全不同的。
比如：
function later() {
answer = answer * 2;
console.log( "Meaning of life:", answer );
}
虽然 later() 的全部内容会被作为一个事件循环队列的入口，然而考虑这段代码运行在一个线程上，实际上可能有许多不同的底层操作。比如，answer = answer * 2 要先加载 answer 的当前值，接着把 2 放在某处，然后做乘法计算，然后取出结果，并把结果存回 answer 中。
在单线程环境下，线程队列中的这些项目是底层操作其实是无所谓的，因为
线程不能被中断。但如果你有一个并行系统，其中两个不同的线程在同一个程序中运行，你很可能得到意想不到的结果。
考虑：
var a = 20;
function foo() {
a = a + 1;
}
function bar() {
a = a * 2;
}
// ajax(..) is some arbitrary Ajax function given by a library
ajax( "http://some.url.1", foo );
ajax( "http://some.url.2", bar );
鉴于 JavaScript 的单线程特性，如果 foo() 在 bar() 之前运行， a 计算的结果为 42，但如果 bar() 在 foo()之前运行，a 的结果将是 41。
如果共享相同数据的 JS 事件并行执行，那么问题就更加微妙了。考虑下面两列伪码， foo() 和 bar() 代码运行时所在的线程执行的是下面两列伪码，思考他们正好同一时刻运行会发生什么。
线程 1 （X 和 Y 是临时内存地址）
foo():
a. load value of `a` in `X`
b. store `1` in `Y`
c. add `X` and `Y`, store result in `X`
d. store value of `X` in `a`
线程 2 （X 和 Y 是临时内存地址）
bar():
a. load value of `a` in `X`
b. store `2` in `Y`
c. multiply `X` and `Y`, store result in `X`
d. store value of `X` in `a`
现在，让我们假设这两个线程真的在并行运行。你可能会发现问题所在，对吗？它们在临时步骤中使用了共享的内存地址 X 和 Y 。
如果上述步骤是这样的， a 的最终结果又是什么呢？
1a (load value of `a` in `X` ==> `20`)
2a (load value of `a` in `X` ==> `20`)
1b (store `1` in `Y` ==> `1`)
2b (store `2` in `Y` ==> `2`)
1c (add `X` and `Y`, store result in `X` ==> `22`)
1d (store value of `X` in `a` ==> `22`)
2c (multiply `X` and `Y`, store result in `X` ==> `44`)
2d (store value of `X` in `a` ==> `44`)
a 的结果将是 44。那这样排列呢？
1a (load value of `a` in `X` ==> `20`)
2a (load value of `a` in `X` ==> `20`)
2b (store `2` in `Y` ==> `2`)
1b (store `1` in `Y` ==> `1`)
2c (multiply `X` and `Y`, store result in `X` ==> `20`)
1c (add `X` and `Y`, store result in `X` ==> `21`)
1d (store value of `X` in `a` ==> `21`)
2d (store value of `X` in `a` ==> `21`)
a 的结果将是 21。
所以，多线程编程是相当复杂的，因为如果你不采取特殊步骤去防止此类冲突和交错的发生的话，你会的到非常意外的不确定的结果，这常常让人头痛不已。
JavaScript 从不跨线程共享数据，这意味着我们不需要担心上述的不确定性。但也不意味着 JS 总是确定的。还记得前面提到的吗？foo() 和 bar() 的相对排列顺序导致了不同的结果（41 或 42）。
注意： 可能至今还不明显，但不是所有的不确定性都是有害的。它有时无关紧要，有时是我们刻意而为的。通过本章节的接下来的一些章节，我们将看到更多的这方面的例子。
完整运行
由于 JavaScript 的单线程特性，foo() 和 bar() 内部的代码是原子的，这意味着一旦 foo() 开始运行，必须要等到这段代码全部执行完毕， bar() 中的代码才能开始运行，反之亦然。这被称为 “完整运行” 行为。
事实上，如果 foo() 和 bar() 包含更多的代码，完整运行的语义会更清晰，比如：
var a = 1;
var b = 2;
function foo() {
a++;
b = b * a;
a = b + 3;
}
function bar() {
b--;
a = 8 + b;
b = a * 2;
}
// ajax(..) is some arbitrary Ajax function given by a library
ajax( "http://some.url.1", foo );
ajax( "http://some.url.2", bar );
因为 foo() 不能被 bar() 中断，bar() 也不能被 foo() 中断，所以这个程序只有两种可能的输出，这取决于哪个先运行——如果存在多线程，而且 foo() 和 bar() 中的语句可以交替运行的话，可能输出结果的数量将大大增加！
块 1 是同步的（当前执行），但 块 2 和 3 是异步的（将来执行），这意味着他们的执行在时间上是分割的。
块 1：
var a = 1;
var b = 2;
块 2（foo()）：
a++;
b = b * a;
a = b + 3;
块 3（bar()）：
b--;
a = 8 + b;
b = a * 2;
块 2 和 块 3 的执行顺序不确定，所以这段程序有两个可能的输出，如下所示：
输出 1：
var a = 1;
var b = 2;
// foo()
a++;
b = b * a;
a = b + 3;
// bar()
b--;
a = 8 + b;
b = a * 2;
a; // 11
b; // 22
输出 2：
var a = 1;
var b = 2;
// bar()
b--;
a = 8 + b;
b = a * 2;
// foo()
a++;
b = b * a;
a = b + 3;
a; // 183
b; // 180
同一段代码有两种输出，这意味着仍然存在着不确定性！但这种不确定性是函数（事件）顺序级别的，而不是多线程下的语句顺序级别（或者说，其实是表达式执行顺序级别）。换句话说，这比多线程还是要确定的多。
在 JavaScript 的特性中，这种函数顺序不确定性就是通常所说的 “竞态条件”，因为 foo() 和 bar() 在相互竞争，来看看谁先运行。具体来说，正因为无法可靠预测 a 和 b 的计算结果，所以它才是 “竞态条件”。
注意：如果 JS 中有个函数，它无论如何也不具备完全执行的特性，我们会有更多种可能的输出，对吧？ES6 就引入了这样一个东西（见第四章 “Generators”），但现在别担心，我们以后会介绍这一部分的！
本系列下一部分将介绍 “并发”