并行线程

人们常常把 “异步” 和 “并行” 这两个术语混淆，但它们其实完全不同。记住，异步是关于 “现在” 和 “将来” 之间的间隙，而并行说的是能够同时发生的事情。

进程和线程是并行计算最常用的工具。进程和线程独立运行，也可能同时运行：在多个独立的处理器上，或者多个独立的计算机上，而多线程可以在同一个进程上共享内存。

相比之下，事件循环将工作分成多个任务，并串行执行它们，不允许对共享内存做并行访问和改变。通过独立线程中的相互协作的事件循环，并行化和 “串行化” 可以共存。

并行线程的交错执行和异步事件的交错执行，其颗粒度是完全不同的。

比如：

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”），但现在别担心，我们以后会介绍这一部分的！

本系列下一部分将介绍 “并发”