【译】异步:现在与将来(并行篇)

Apr 01 2017 前端

并行线程

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

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

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

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

比如:

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 (XY 是临时内存地址)

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 (XY 是临时内存地址)

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`

现在,让我们假设这两个线程真的在并行运行。你可能会发现问题所在,对吗?它们在临时步骤中使用了共享的内存地址 XY

如果上述步骤是这样的, 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”),但现在别担心,我们以后会介绍这一部分的!


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

JavaScript, 翻译