并行线程

“异步”与“并行”两个词经常被混为一谈，但它们实际上是十分不同的。记住，异步是关于 现在 与 稍后 之间的间隙。但并行是关于可以同时发生的事情。

关于并行计算最常见的工具就是进程与线程。进程和线程独立地，可能同时地执行：在不同的处理器上，甚至在不同的计算机上，而多个线程可以共享一个进程的内存资源。

相比之下，一个事件轮询将它的工作打碎成一系列任务并串行地执行它们，不允许并行访问和更改共享的内存。并行与“串行”可能以在不同线程上的事件轮询协作的形式共存。

并行线程执行的穿插，与异步事件的穿插发生在完全不同的粒度等级上：

比如：

  1. function later() {
  2.     answer = answer * 2;
  3.     console.log( "Meaning of life:", answer );
  4. }

虽然later()的整个内容将被当做一个事件轮询队列的实体，但当考虑到将要执行这段代码的线程时，实际上也许会有许多不同的底层操作。比如，answer = answer * 2首先需要读取当前answer的值，再把2放在某个地方，然后进行乘法计算，最后把结果存回到answer。

在一个单线程环境中，线程队列中的内容都是底层操作真的无关紧要，因为没有什么可以打断线程。但如果你有一个并行系统，在同一个程序中有两个不同的线程，你很可能会得到无法预测的行为：

考虑这段代码：

  1. var a = 20;
  3. function foo() {
  4.     a = a + 1;
  5. }
  7. function bar() {
  8.     a = a * 2;
  9. }
  11. // ajax(..) 是一个给定的库中的随意Ajax函数
  12. ajax( "http://some.url.1", foo );
  13. ajax( "http://some.url.2", bar );

在JavaScript的单线程行为下，如果foo()在bar()之前执行，结果a是42，但如果bar()在foo()之前执行，结果a将是41。

如果JS事件共享相同的并列执行数据，问题将会变得微妙得多。考虑这两个假想代码段，它们分别描述了运行foo()和bar()中代码的线程将要执行的任务，并考虑如果它们在完全相同的时刻运行会发生什么：

线程1（X和Y是临时的内存位置）：

  1. foo():
  2.     a. 将`a`的值读取到`X`
  3.     b. 将`1`存入`Y`
  4.     c. 把`X`和`Y`相加，将结果存入`X`
  5.   d. 将`X`的值存入`a`

线程2（X和Y是临时的内存位置）：

  1. bar():
  2.   a. 将`a`的值读取到`X`
  3.     b. 将`2`存入`Y`
  4.     c. 把`X`和`Y`相乘，将结果存入`X`
  5.     d. 将`X`的值存入`a`

现在，让我们假定这两个线程在并行执行。你可能发现了问题，对吧？它们在临时的步骤中使用共享的内存位置X和Y。

如果步骤像这样发生，a的最终结果什么？

  1. 1a  (将`a`的值读取到`X`   ==> `20`)
  2. 2a  (将`a`的值读取到`X`   ==> `20`)
  3. 1b  (将`1`存入`Y`   ==> `1`)
  4. 2b  (将`2`存入`Y`   ==> `2`)
  5. 1c  (把`X`和`Y`相加，将结果存入`X`   ==> `22`)
  6. 1d  (将`X`的值存入`a`   ==> `22`)
  7. 2c  (把`X`和`Y`相乘，将结果存入`X`   ==> `44`)
  8. 2d  (将`X`的值存入`a`   ==> `44`)

a中的结果将是44。那么这种顺序呢？

  1. 1a  (将`a`的值读取到`X`   ==> `20`)
  2. 2a  (将`a`的值读取到`X`   ==> `20`)
  3. 2b  (将`2`存入`Y`   ==> `2`)
  4. 1b  (将`1`存入`Y`   ==> `1`)
  5. 2c  (把`X`和`Y`相乘，将结果存入`X`   ==> `20`)
  6. 1c  (把`X`和`Y`相加，将结果存入`X`   ==> `21`)
  7. 1d  (将`X`的值存入`a`   ==> `21`)
  8. 2d  (将`X`的值存入`a`   ==> `21`)

a中的结果将是21。

所以，关于线程的编程十分刁钻，因为如果你不采取特殊的步骤来防止这样的干扰/穿插，你会得到令人非常诧异的，不确定的行为。这通常让人头疼。

JavaScript从不跨线程共享数据，这意味着不必关心这一层的不确定性。但这并不意味着JS总是确定性的。记得前面foo()和bar()的相对顺序产生两个不同的结果吗（41或42）？

注意： 可能还不明显，但不是所有的不确定性都是坏的。有时候它无关紧要，有时候它是故意的。我们会在本章和后续几章中看到更多的例子。

运行至完成

因为JavaScript是单线程的，foo()（和bar()）中的代码是原子性的，这意味着一旦foo()开始运行，它的全部代码都会在bar()中的任何代码可以运行之前执行完成，反之亦然。这称为“运行至完成”行为。

事实上，运行至完成的语义会在foo()与bar()中有更多的代码时更明显，比如：

  1. var a = 1;
  2. var b = 2;
  4. function foo() {
  5.     a++;
  6.     b = b * a;
  7.     a = b + 3;
  8. }
  10. function bar() {
  11.     b--;
  12.     a = 8 + b;
  13.     b = a * 2;
  14. }
  16. // ajax(..) 是某个包中任意的Ajax函数
  17. ajax( "http://some.url.1", foo );
  18. ajax( "http://some.url.2", bar );

因为foo()不能被bar()打断，而且bar()不能被foo()打断，所以这个程序根据哪一个先执行只有两种可能的结果——如果线程存在，foo()和bar()中的每一个语句都可能被穿插，可能的结果数量将会极大地增长!

代码块儿1是同步的（现在 发生），但代码块儿2和3是异步的（稍后 发生），这意味着它们的执行将会被时间的间隙分开。

代码块儿1:

  1. var a = 1;
  2. var b = 2;

代码块儿2 (foo()):

  1. a++;
  2. b = b * a;
  3. a = b + 3;

代码块儿3 (bar()):

  1. b--;
  2. a = 8 + b;
  3. b = a * 2;

代码块儿2和3哪一个都有可能先执行，所以这个程序有两个可能的结果，正如这里展示的：

结果1:

  1. var a = 1;
  2. var b = 2;
  4. // foo()
  5. a++;
  6. b = b * a;
  7. a = b + 3;
  9. // bar()
  10. b--;
  11. a = 8 + b;
  12. b = a * 2;
  14. a; // 11
  15. b; // 22

结果2:

  1. var a = 1;
  2. var b = 2;
  4. // bar()
  5. b--;
  6. a = 8 + b;
  7. b = a * 2;
  9. // foo()
  10. a++;
  11. b = b * a;
  12. a = b + 3;
  14. a; // 183
  15. b; // 180

同一段代码有两种结果仍然意味着不确定性！但是这是在函数（事件）顺序的水平上，而不是在使用线程时语句顺序的水平上（或者说，实际上是表达式操作的顺序上）。换句话说，他比线程更具有 确定性。

当套用到JavaScript行为时，这种函数顺序的不确定性通常称为“竞合状态”，因为foo()和bar()在互相竞争看谁会先运行。明确地说，它是一个“竞合状态”因为你不能可靠地预测a与b将如何产生。

注意： 如果在JS中不知怎的有一个函数没有运行至完成的行为，我们会有更多可能的结果，对吧？ES6中引入一个这样的东西（见第四章“生成器”），但现在不要担心，我们会回头讨论它。