
Python部落(python.freelycode.com)组织翻译,禁止转载,欢迎转发。
做芦苇,而不是橡树。绿色线程(green threads)就只是线程。
坚强者死之徒,柔弱者生之徒。(道德经,第七十六章)
问题:线程很糟糕
(在很多场合,)线程很糟糕。线程使局部推理变得困难,局部推理很可能是软件开发中最重要的事了。
这里的线程是指共享状态的多线程,而不是Erlang和Haskell等语言里的线程(它们指的是并发进程--不能隐式共享状态,而需要显式协调)。
我的经验主要是(但不完全是)Python。但是这里提出的想法应该可以推广到大多数具有全局共享可变状态的语言,即大部分编程语言:C,C#,Objective C,C++,JS, Java,Scheme,Ruby,PHP等等。
局部推理是指通过检查一个程序而不是整个系统就可以了解这个程序的行为(和正确性)。
当你在看一个单任务、非并发系统里的只有几个状态的程序,你只需要想程序开始时的状态,和程序结束时的状态。为了猜测不同的状态,你只需要阅读程序并且想象从上到下执行它的指令。这意味着你需要考虑n条指令,即程序包含的指令数目。相反,在一个具有任意并发执行的系统中--在这里多个线程可能同时使用相同的状态执行这个程序--你不得不按任何可能的顺序阅读代码,复杂度为n^n。
因此理解一个可能被任意数目线程并发执行的程序异常困难。你要考虑程序中每一个可能的调用者,知道它们来自哪个线程,或者它们可能共享什么状态。如果你在编写一个线程安全的库,那么你必须把这些思考中的一部分负担留给调用者。
局部推理的重要性真的不能被夸大。至少目前,计算机程序是人类创造的,他们考虑各种情形。正确的计算机程序是由那些人写出来的,他们能够同时考虑正在设计的系统中的一部分和其他部分的所有可能的交互。
人类只能同时思考7(+/-2)件事。因此,虽然随着时间推移,我们可能开发出包含数千的,数百万计的,或者数十亿组件的系统,但是我们必须能够在平均只能同时思考七件事的情形下对系统做出改变。糟糕的系统会使我们集中在九件事情上,只有在最好的状态下我们才能正确的写出他们。好的系统只需要我们集中在五件事情上,即使在疲劳的时候我们也可以写出正确的代码。
旁白:“哦,拜托,他们并没有那么糟糕”
你们中一些使用线程编写软件的人可能会反对这点。“没有人会尝试写这样的线程安全(free-threading)代码,”我听到你们在抱怨,“当然,如果操作状态,我们会在一些关键部分使用锁或者队列”。
互斥量会减轻这一问题,但是他们不能消除它,并且他们也有自己的问题;你需要制定策略确保他们的获得保持一致的顺序。互斥量应该用于创建队列,避免死锁,这些队列应该是非阻塞的,但是一个仅靠非阻塞队列通信的系统最终将变为一个通信事件循环的集合,这样它变成了一个事件驱动系统;它再也不是通常的线程编程了。
但是即使你创建了一个这样的系统,如果你使用一种编程语言比如Python(或者上面提到过的一种),它的模块、类和方法都是全局共享、可变的状态,那么在你毫无意识的修改变量时就很可能犯一个影响整个程序行为的错误。你必须极其警惕以确保你的规则,状态在哪里可以被谁操作,因为当这造成一个bug时几乎不能找到它发生在哪里。
当然,线程只是众多难以捉摸的烧脑bug之一,并且你经常可以做出可行的假设,避免真得需要平方级增加你接触到的每一个程序的复杂度。另外,,许多计算一点也不需修改状态,这样你就可以忽略每一行代码上都可能发生的很多事情。(如果你不这样认为,你最后一次检查代码在内存分配失败时的正确行为是什么时候?)所以,在某种意义上,编写出真正的线程多少有一点执行正确的系统是可能的,原因与可能编写出近似正确的任何程序一样;有时我们都需要对我们神圣的事业有一点力量和信息。
虽然如此,我仍然认为如果可以避免却依然给自己找麻烦是一个坏想法。
解决方法:不使用线程
所以现在我已经说服你们如果使用Python编程(或者其他任一门和它在并发和状态方面一样的语言)就不应该使用线程。太好了。你要怎么做才能替代线程呢?
有很多关于最好的异步编程方式的争论--就是说,“不使用线程”,经常有四个选项。
直接回调(straight callbacks):Twisted的IProtocol,JS的on<foo>语法,给某方法(将会稍后调用回调函数)传入一个回调函数,然后把控制权交给程序其他部分(将会执行回调函数,通常是主循环)
代理回调(managed callbacks)或Futures:Twisted的延迟对象Deferred,JS的Promises/A[+],E的Promises,创建一个专门的保证结果将来有效的对象并返回这个对象给添加回调函数的调用者
显式协程(explicit coroutines):Twisted的@inlineCallbacks,Tulip的yield from协同程序,C#的async/await,有一个语法特征--明确暂停当前程序
最后,隐式协程(implicit coroutines):Java的green threads,Twisted的Corotwine,eventlet,gevent,通过调用暂停它的函数,任何函数可以切换当前线程控制的全部栈。
这几种方式互不相同,互不包含。
不要使用这些方法
选项1-3都相当于在一个有状态的系统中合作控制转移。他们是线程的语法改善。回调函数,Futures和基于Yield的协程都考虑到并发操作的局部推理。
所以为什么选项4竟然出现在这个列表里?
不幸的是,异步系统经常以一个有点可疑的优化推广,这个优化允许I/O密集型并发比优先线程更高级,而不是我上面解释的以线程作为编程模型。通过异步协程这种描述方式,就可以把上面4个选项列在一块。
我对此常常感到内疚,尤其是过去几年:使用Twisted的系统比以其它方式使用线程的系统更高效。在很多情况下那是对的,但是:
当涉及性能时,这种情况总是比那种复杂,
实际编程中上下文切换很少是瓶颈,
这只是事件驱动编程巨大优势中的一小部分,简单点说就是,更易于编写大规模的两类程序(即包含大量代码的程序和有许多并发用户的程序)
提供隐式协程的系统--没有任何语法暗示就可以将控制权转移给栈上任一层的另一个并发任务--本身仅仅是可疑的优化
虽然隐式协程有很多不同的名字,很多都不包含“线程”这个词--比如, “greenlets”,“coroutines”,“fibers”,“tasks”--绿色或轻量线程确实是线程,因此他们有相同的问题。从长远看,当你创建一个依赖它们的系统,你最终会有所有完全优先级线程所有的陷阱和危险。上面描述过,这些是糟糕的。
如果你检查一个用callbacks或者yielding coroutines编写的并发程序,可以直观的看到它在什么地方让出控制权,给其他程序或者再次进入同样的程序。如果你使用callbacks-managed或者其他的--你将看到一个return语句,或者程序的结束位置,这使主循环继续执行。如果你使用explicit roroutines,你将看到一个yield(或await)语句暂停程序。因为你可以看到这些并发的迹象,它们在你的文本编辑器里而不是脑海里,所以当你使用它们时不需要牢牢记住它们。
你可以把这些隐式的让出点认为是程序优雅地转向并发输入需求。缓冲区或者溢流阀(你想怎么叫就怎么叫):一个单独的点,你必须考虑在这里控制权转交给程序其它部分的可能,而不是一个死板的程序,可能在任何超出你控制的地方转移或中断。
像缓冲区,你不能有太多,否则失去效力。一个长的程序,在显式转移点之前的每一条指令只需要尽可能多的顺序执行,因此很难出错,但是任何指令前的上下文切换可能出错。明确插入转移点的优点是你至少可以发现一个程序什么时候产生这个问题,并开始清理、巩固并发性的管理。
但是这十分抽象;我来展示一个具体的实例,以及一个简短的理论论证。
最古怪的bug
当我们写出最初的Python版Twisted Reality时,Java版的已经使用了green threads;那时,JVM没有其他类的线程。我们开发的新网络层的优点不是性能的巨大飞跃(这里的软件是一个多用户文本冒险游戏,人数最多时有30多人同时玩)而是可怕的不可追溯的并发bugs的数目和严重程度的急剧减少。尤其是那个黄铜的会爬上一个计时器的机械蟑螂,如果它在玩家的库存里就会从玩家手里跳出来,否则就在房子间移动。在多线程版本里,蟑螂会从你的手里跳出来,但是会仍然呆在你的手里。当蟑螂在房子间移动时,就会创建自己的浅克隆蟑螂(shadow copies),缓慢但不可避免的创建一个蟑螂末日,因为成千上万的指针指向那个蟑螂,每一只都以某种方式获得一个属于它们自己定时器,它们进入每个玩家库存的方式遭到数十倍的破坏。
用这种独特的叙事特征是为了鼓励奇特的想法而不是恐怖,线程引入的不确定性是一个严重的问题。我们用事件驱动重新写的期望仅仅只是能够通过逐步调试来诊断bug;这样,bug就会消失了。(你会牢记这些,因为你很少能听到一个头发花白的Twisted前辈把一个棘手的问题称为一个黄铜蟑螂。)
bug的原始来源非常难改正,以至于唯一可行的办法是从头重写整个系统。经过数月的调试,测试和检查,它仍然会间歇性的出现,几个“修复”(对代码随机绝望的修改)不会起任何作用。
我绝不会再那样做了。
Ca(sh|che Coherent) Money
虽然(我希望)上面的例子很有趣,仍然很难想象并发是如何导致那样的bug的,并且那个例子的代码太过庞大,不能作为一个有用的解释。所以,这有一个较小的例子。相信我,上面的bug来源于很多很多下面描述的问题的交叉例子。
碰巧的是,这与Guildo van Rossum解释为什么即将到来的asyncio模块标准库(来源于郁金香项目)使用显式协程而非绿色线程的例子是相似的,所以实际上,很多人都碰到过这个问题。
看一下这个程序:

(我发现在这个例子里操作的顺序有点奇怪,但是这样很容易证明观点,所以请“迁就”我一下)
如果没有并发的话,这当然是正确的。如果你连续运行transfer两次,两个账户的余额总是正确的。但是如果我们在任意数目的线程上使用两个相同的账户同时运行transfer,那将是(显然,我希望)是错误的。当一个线程检查完余额是否充足后但在更改账户余额之前,另一个线程可能会更新同一个账户的余额而使余额低于使用额度。
按照PEP 3156的格式将它写为并发的。update_balance程序应该进行网络连接并且阻塞,就像下面这样:

现在,我们有了一个这个程序并发的正确的版本(还需要一点小的改善)。无论sufficient_funds_for_withdrawl,deposit和whithdrawl做什么--即使进行网络读写--我们不需要等待他们都完成,所以他们不能调用transfer。简便起见,我们假设update_balances是魔法;使付款人和收款人的账户保持一致。
但是如果我们使用绿色线程作为异步机制而不是corotines和yields,那么我们就不需要对程序做一点修改。那不是更好吗?无论如何只有updata_balance会阻塞,所以,它不也是正确的?
目前来讲是这样的。
但是现在对代码进行一点细微的改动:假设操作团队要求我们把所有日志消息上传到一个网络日志收集系统进行分析。一个合理的请求,所以我们修改log的实现来向网络写。
现在,我们必须对绿色线程版本的代码做哪些修改呢?完全不用!绿色线程的拥护者们经常会指出自豪地这一点,虽然修改了日志系统来读写网络,但是支付系统的代码完全不用修改。关注分离!少做无用功!看起来绿色线程赢了。
然而作为一个隐式协程的拥护者,我还是做一下那些显然不必要的工作来更新ledger代码。

至少这不是很难,只是有点无聊。唉,我觉得现在可以更新所有ledger的调用者......
……等一下。
为了将这个程序更新为一个非阻塞log,我们需要在suffiecient_funds_for_withdrawl检查和withdraw调用,deposit调用和withdraw调用,以及whithdraw调用和update_balances调用之间键入关键字yield。如果不了解并发和这个程序,任一个yield都是一个潜在的问题。如果调用log并阻塞,一个付款者可能检测账户金额是否足够,那么账户金额就可能在log执行时减少,余额成为一个负值。
更新大量代码的时候可能会盲目的添加yield关键字而没有注意到那个错误。我也曾经这样做过。从今以后,都应该记着,仅仅机械的打出这些很可能哪里出错了。即使我们这样改完了而且没有发现错误,那么当注意到余额为负数时,我们只应该检查transfer程序中那些关键字yield from出现的地方,而不应该考虑它调用的程序的行为。
进行这些琐碎的修改时,我们可能会想到:在程序继续执行之前真的需要等待日志信息被传到日志系统吗?答案可能永远都是“不”。log的一个巧妙实现可以对传给日志系统的信息排队,丢弃过多的,当日志系统跟不上时拒绝任何调用来减缓压力或者慢下来。考虑syslog说“再来几个”的情况而不是重复纪录某些信息。这样可以避免日志里有过多重复的信息,而且减少了日志写入磁盘缓慢时需要缓存的东西。
因此,当修改log为异步时更新log调用者所要做的额外工作是一个特征。这可能很乏味,一个独立程序的异步性实际是指它的所有调用者都必须知道的那些东西,就像他们必须知道它的参数和返回类型。
实际上你在修改它的返回类型:在Twisted里,返回类型应该是Deferred,在Tulip里,返回类型应该是一种新型的生成器。新的返回值类型表示将一个函数变为并发时采用的新的语法。
Haskell这点做的很好,在任何可能并发的函数的返回类型中嵌入IO monad。这就是某些人说Deferred是一个Monad时所指的。
轻量级和重量级线程之间的主要区别是,轻量级线程有严格的规则比如“绝对不要共享不必要的状态”,“总是为每个程序的每个可能暂停的地方编写测试”,如果你完全理解了这些,你至少可能写出一个行为确定且正确的程序。当程序暂停在一个以前没有暂停过的地方而引起一个意外的bug时,对于轻量级进程,可以编写一个确定性测试检查代码。然而对于重量级线程,每一行都可能在任意时间发生上下文切换,所以很难为代码执行的全部顺序写出测试代码。
然而,对于轻量级线程,你不可能写出一个测试来发现会引起问题的yield位置,所以你需要检查每一个yield位置。
虽然这样做可行,但是这仍然很麻烦。就像我上面说的,对于Python,JavaScript,PHP等语言,代码本身可能就是共享的可变状态。类,类型,函数以及命名空间都是共享的,可变的。程序库像对象关系映射通常用类来存储状态。
并没有捷径
虽然上面说着那么多线程的坏话,我写这篇文章的主要意图并不是说服你线程是糟糕的。(但愿你在开始读这篇文章之前就相信了。)我所希望的是如果你同意我的观点,线程有不确定的语义,并且很难说清原因,那么使用微线程就没有什么特别的优点,除了可能优化针对某一个非常具体的I/O负载的代码。
没有使单任务代码并发的捷径。它就是一个难题,从敲击一堆并发特定代码的难度就可以看出。
所以不要被愚弄:线程就是线程,不论它是什么“颜色”。如果你想要程序在并发时灵活且有弹性,那么当并发的“风暴雨”到来时,允许它改变。告诉它要柔软,就像芦苇一样。否则,就会像暴风雨里宁折不弯的橡树一样,你宁折不弯的程序将拦腰折断。
英文原文:https://glyph.twistedmatrix.com/2014/02/unyielding.html
译者:CupKnight

