并行计算--并发构造纵览

作者简介：

孙奇辉,现任某电信公司软件工程师。对面向对象分析和设计，函数式编程，并行计算等有浓厚兴趣。

Blog:http://blog.csdn.net/sunqihui;

      E-mail: [e-mail];

         QQ:103561996;

         MSN:[e-mail]。

版本：2010-10-22。

目录

并发构造纵览... 1

一、多线程Multi-Threading并发模型... 2

二、并发的设计目标和空间... 3

三、有利于构造并发的几种理论模型... 4

1、Actors(动作者/角色) 4

2、CSP(Communicating sequential processes) 4

3、CCS(Calculus of Communicating Systems) 4

4、Petri-net（Petri 网）... 4

5、Pi-calculus(π演算) 5

6、Join-calculus（Join演算）... 5

7、Functional Programming（函数式编程）... 5

四、并发构造实现时的问题... 5

五、软件事务内存STM.. 6

六、持久化数据结Persistent Data Structure. 7

七、消息传递Message-Passing. 8

Actors模型... 8

八、数据流Dataflow.. 10

九、元组空间Tuplespace. 12

十、参考... 13

 

 

本文是从Ted Leung （Jython的主要开发者之一）的一次演讲《A Survey of Concurrency Constructs》中翻译整理而来，并补充了相关解释以飨读者，开阔视野。

文中简述了当今世界各主要的语言级并发构造， 并扼要点评了它们的特色和存在的问题，此文希望能激发国内广大程序员对并行/并发技术的兴趣，为其并发思想库添砖加瓦。有少许并发编程经验的读者会更利于理解此文。

以下提到的每一种编程模型或并发构造如果详述的话，都能写成一本书或册子，限于篇幅，本文并没有展开详述。如果想掌握这些概念和技术，需要更多的学习和一定时间的练习。

今天的程序员，对自己工作用的或家里的机器，装有几个核应该都很清楚了，但是对于并发编程，能够说清楚的，恐怕不多。大多数可能只听说过多线程，很少有（至少在我工作的这多年接触的程序员中）亲手编写过并发程序的。咱们的纵览就从多线程开始吧。

一、多线程Multi-Threading并发模型

多线程是最常见的语言级并发构造，例如在Java、C#等主流语言中都存在。多线程会涉及到对共享状态（即面向对象中的实例字段等）的并发修改，为了确保同步，常常会用到锁和互斥。举个简单的Java多线程例子：

public class Account {

    private double balance = 1000.0;

 

    public double getBalance() {

       return balance;

    }

 

    public void deposit(double amount) {

       this.balance += amount;

    }

 

    public void withdraw(double amount) {

       this.balance -= amount;

    }

 

    public static void main(String[] args) {

       final Account someoneAccount = new Account();

 

       Thread depositSalary = new Thread(new Runnable() {

           public void run() {

              someoneAccount.deposit(1600.0);

           }

       });

 

       Thread withdrawInsurance = new Thread(new Runnable() {

           public void run() {

              someoneAccount.withdraw(300.0);

           }

       });

      

       depositSalary.start();

       withdrawInsurance.start();

 

try {

           Thread.sleep(1000);

       } catch (InterruptedException e) {

           e.printStackTrace();

       }

       System.out.println(someoneAccount.getBalance());//这儿一定是2300吗？

    }

}

或许我们期待这个程序的输出永远为2300，因为不论是先存薪水还是先交保险，余额应该是2300。熟悉Java多线程读者可能已经知道，其实存在这种可能，存薪水线程开始取得的余额是1000，而交保险线程开始取得的的余额也是1000！这样它们并发地在1000上操作，所以最终的余额可能是它们任一操作的结果：可能是2600（账号拥有者会感到高兴），也可能是700（账号拥有者会愤怒了）。于是，简单的解决办法是为deposit和withdraw方法加上synchronized，即Java的内置锁，但是如果为了正确性，到处用synchronized方法，不断影响性能，而且可能会导致死锁、活锁等情况（更多介绍请参阅《Java并发编程实践》）。

多线程存在以下的缺点：

         手动地lock 和unlock；

         Lock顺序是个大问题，容易造成死锁；

         锁不是组合的。

         随着GPGPU的出现，线程的概念也越来越复杂了，在CUDA,OpenCL、DirectCompute中，线程的意义存在微妙的差异。

         要克服多线程的这些缺点，需要更好的并发编程模型和并发构造。多线程也常是其它并发构造的基础，好的并发构造，应该超越目前的多线程构造，需要考虑如下的设计目标和空间：

 

二、并发的设计目标和空间

         互斥：对于临界区的访问需要互斥；

         串行/排序：对于并发的修改需要某种形式的串行化和排序；

         内在的/隐式的 vs 显式的：隐式的并发（下文讲的数据流即是隐式的）与显式的并发的取舍；

         细/中/粗粒度：构造并发任务的粒度，支持的级别；

         可组合能力：多种并发构造的组合能力。

因而，好的并发解决方案应该有能力：

         减少潜在的错误；

         容易识别并发性：任务并行或数据并行；

         可伸缩地运行于今天和未来的并行硬件上。

 

计算机科学发展至今，发展起来了许多有利于构造并发的理论，这些理论除了在科研和教育领域有实践外，在商业上的大型机和高性能计算领域也有较长的成功实现的历史。下面扼要地简介下这几种理论模型。

三、有利于构造并发的几种理论模型

      1、Actors(动作者/角色)

         在计算机科学中，动作者模型是一种并行计算模型。“动作者”是一种程序上的抽象概念，被视为并行计算的 基本单元：当一个动作者接收到一则消息，它可以做出一些决策、建立更多的参与者、传送更多的消息、决定要如何应答接下来的消息。动作者模式在1973年于Carl Hewitt、Peter Bishop及Richard Steiger的论文中提出。

         一个动作者是一个计算实体，对收到的消息作出响应，它能并发地

         发送有限数量的消息到另一个动作者

         创建有限数量的新动作者

         指派用于下一个收到的消息的行为

动作者模型作为消息传递模式，能够异步通信和像控制结构样使用，从通信解耦发送者是动作者模型的基本优势。更多介绍参见http://en.wikipedia.org/wiki/Actor_model。

2、CSP(Communicating sequential processes)

         在计算机科学中，通信顺序进程用来描述并发系统中的交互模式。它是并发数学理论例如进程代数或进程演算家族中的一员。CSP首先被C. A. R. Hoare,于1978年的论文中描述。如其名所示，CSP允许组件进程彼此独立地通过消息传递交互来描述系统。然而其名称中的“顺序”有点不正确，因为现代CSP允许组件进程定义为顺序的，也可以由多个基本进程并行地组合。不同进程间的关系，及每个进程与其环境通信的方式，可用各种进程代数操作来描述。用进程代数的方式，非常复杂的进程描述也能容易地由几个基本元素构造。更多介绍参见http://en.wikipedia.org/wiki/Communicating_sequential_processes。

3、CCS(Calculus of Communicating Systems)

         通信系统演算（CCS）是一种进程演算，由Robin Milner约于1980引入。它的动作模拟两个参与者间不可见的通信。其形式语言包括描述动作和范围限定间的并行组合和选择。CCS可用于评估系统属性的正确性，例如死锁和活锁。更多介绍参见http://en.wikipedia.org/wiki/Calculus_of_Communicating_Systems。

4、Petri-net（Petri 网）

         Petri-net(也叫place/transitionnet 或P/T net ),是几种用于描述分布式系统的数学建模语言之一。一个Petri网是有向双向图，其节点表示转换（也即可发生事件，由条形所示）和位置（也即条件，由圆形所示）。有向的箭头描述了哪个位置是哪个转换的前置和/或后置条件。Petri-net由Carl Adam Petri发明于1939年。更多介绍参见http://en.wikipedia.org/wiki/Petri_net。

5、Pi-calculus(π演算)

         在理论计算机科学中，π演算是一种进程演算，起源于Robin Milner, Joachim Parrow and David Walker在CCS进程演算上的后续工作。π演算的目的是能够描述并发计算，其配置可以在计算期间变化。π演算属于进程演算家族，即描述和分析并发计算性质的数学形式。事实上，π演算像λ演算，定义了极小的范畴，以至于没包含基本原语，例如数字，布尔和常用控制结构等等。更多介绍参见http://en.wikipedia.org/wiki/Pi-calculus。

6、Join-calculus（Join演算）

         Join演算是一种进程演算，由法国计算机科学和控制国家研究所开发。Join演算提供了设计分布式编程语言的形式基础，并且有意避免了其它进程中的通信构造，例如rendezvous--它在分布式设置里难于实现。尽管有此限制，Join演算有与完全的π演算一样的表达能力。用Join演算编码π演算，反之亦然，已经被论证过了。更多介绍参见http://en.wikipedia.org/wiki/Join-calculus。

7、Functional Programming（函数式编程）

在计算机科学中，函数式编程是一种编程范型，其把计算作为求值数学函数对待，并且避免状态和可变数据。其强调应用函数，相对于命令式编程风格强调改变状态。函数式编程的根基在于lambda演算，开发于1930s的用于考察函数定义，函数应用和递归的形式系统。

实践中，数学函数与命令式编程中的“函数”间的差异在于命令式函数能有副作用，其改变已经计算过的值。因而命令式编程中的函数缺乏引用透明性，即同样的表达式在不同的时间可能导致不同的值，依赖于执行程序的状态。相对地，函数式编程中，函数的输出值仅依赖于其输入参数。更多介绍参见http://en.wikipedia.org/wiki/Functional_programming。

四、并发构造实现时的问题

         实现高效的并发构造，各具体的模型需要考虑以下几种开销：

         线程（线程通常是其它并发构造的基础）创建和销毁的开销，当今支持较好并发的语言基本上提供了轻量级或基于事件的线程；

         消息发送的开销，在一些优化的并发VM上，底层可能会通过共享内存的方式在多核心机器上传递只读的消息；

         上下文/线程切换的开销；

         锁获取/释放的开销。

 

除了传统的基于锁和互斥的多线程模型外，目前得到实践检验，在一些并发功能突出的语言中应用的并发编程模型还有：

 

         TransactionalMemory （事务内存）

         PersistentData Structures（持久化数据结构，通常与STM结合使用）

         Actors(动作者/角色)

         Dataflow(数据流)

         Tuplespaces(元组空间)

        

 

以下分别简述这几种并发构造的历史、特点和不足。了解Clojure、Erlang、F# 或Scala等并发功能突出的语言的读者会较容易理解下文；以下的例子和图示展示了这些并发构造的精华。

五、软件事务内存STM

历史：

         最初的STM论文出现在1995年；

         这一想法早在1986年就出现了，Tom Knight提到了硬件事务内存；

         第一次出现于编程语言，是在ConcurrentHaskell 2005。

 

STM的特点：

         在内存中的数据项上使用事务；

         在begin/end块里包装代码；

         指明手动中止或重试的操作；

         手动中止时可指明可选的执行路径。

 

Clojure语言(http://clojure.org)中的STM支持数据库事务ACID中的ACI，即原子性、一致性、隔离性，因为它是内存中的事务，所以没提供数据的持久性存储（例如像数据库样保存在硬盘上）。以下为Clojure中的一个例子：

         (defndeposit [account amount]              ;定义了一个存款函数，对账号存指定金额

 (dosync                                                                 ;启用STM

   (let [owner (account :owner)                     ;绑定账号

                   balance-ref(account :balance-ref)] ;绑定指向账号的引用

     (do                                                                ;执行

                  (alter balance-ref + amount)            ;修改账号余额

                  (println “depositing” amount (account:owner))))))) ;打印结果

Clojure是JVM上的一种现代的LISP方言。熟悉LISP的读者应该能明白以上代码的意思。各行后面有简短的注释（Clojure中的注释以;号开始）。

 

 

STM设计空间涉及的算法/策略：

                   事务的粒度，字word或块block级的粒度

                   锁 vs 乐观并发；

                   冲突检测，积极或延迟检测；

                   竟争管理。

        

 

STM不足和要注意的:

非事务的代码访问STM 中的引用；

不可中止的操作，如I/O；

STM开销：读写屏障消除；

哪儿放置事务边界较合适；

仍然需要条件变量，问题的排序很重要。

 

当编程语言中的STM实现有：

         Haskell/GHC

                   使用logs和aborts txns

         ClojureSTM –via Refs

                   基于ML Refs限制改变，但ML Refs没有自动并发语义；

                   只为Refs聚合；

                   用MVCC(多版本并发控制)实现；

                   持久化数据结构启用MVCC可分离读取者和写入者（读取者不等待）。

 

六、持久化数据结Persistent Data Structure

历史：

 

初始形成于约1981；

Sarnoff形式化于1986；

由Clojure流行开来；

 

PDS的特点：

当update的时候，前一版本的数据仍然可用，保持数据的功能性，会保持对应的可变版本的 big-O 效率；

         在Clojure,PDS与STM组合一起，受写时复制（copyon write）激发，有Hash-map,vector,sorted map等。

 

可用的数据结构：

Lists, Vectors, Maps

 hash list basedon VLists

 VDList - deques based on VLists

 red-black trees

 Real Time Queuesand Deques

 deques,output-restricted deques

 binary randomaccess lists

 binomial heaps

 skew binaryrandom access lists

 skew binomialheaps

 catenable lists

 heaps withefficient merging

 catenable deques

 

PDS不足：

         不完整的模型，它不能解决所有并发问题；

         面向函数式编程。

七、消息传递Message-Passing

Actors模型

         历史：

由Carl Hewitt 发明于 MIT（1973），         形式模型，编程语言，硬件，由Scheme延续；

                  近来由Erlang中兴起来，Erlang的模型不是明确地派生于Actors。

        

         Actors模型思考：

                   Actor的消息队列的分布式服务；

                   多个actor协作，  重新使用事务？

                   Actors仍会死锁和饥饿；

                   程序员定义粒度，得选择什么是一个actor。

        

         支持Actor模型的编程语言有：

                   ScalaActors 和Lift Actors

                   Erlang

                   CLR,F#/ Axum

 

Actor变种：

         Kamaelia

                   消息发到命名的信箱

                   协作语言连接发件箱和收件箱

                   信箱大小可控制

         Clojure Agents（动作者/代理）

                            为松耦合的情况设计

              代码/动作发到agents

              当到达agents时代码会被排队

              Agents框架保证串行

              Agents的状态对读取操作总是可用（不像actors）

              不支持透明的分布式

              能在‘开放世界’里操作—actors响应特定集合的消息

 

 

以下为Actors的一个简短示意图；再下面是Scala语言(http://www.scala-lang.org)的一个例子，代码后面也有简短注释。

object accountextends Actor {                           //单例对象账号继承于Actor类

  private var balance = 0                                     //声明和初始化私有变量--余额

  def act() {                                                             //覆写act()方法

    loop {                                                                //循环处理Actor的消息队列

      react {                                                          //动作代码，接收消息并处理

         case Withdraw(amount) =>                       //尝试模式匹配，取款类

                   balance -= amount                                        //匹配上，则减少余额

                   sender ! Balance(balance)                          //并向发送者响应消息--当前余额

         case Deposit(amount) =>                           //尝试模式匹配，存款类

                   balance += amount                                       //匹配上，则增加余额

                   sender ! Balance(balance)                          //并向发送者响应消息--当前余额

         case BalanceRequest =>                             //尝试模式匹配，余额请求类

                   sender ! Balance(balance)                          //匹配上，向发送者响应消息--当前余额

         case TerminateRequest =>                        //尝试模式匹配，终止请求类，忽略此消息

     }

  }

}

八、数据流Dataflow

         历史：

                   BillAckman的博士论文于MIT(1984)；

                   函数式语言中声明式并发；

                   在1980和90年代得到研究；

                   内在的并发，导致实现困难；

                   研究者对声明式并发的兴趣在慢慢地回归。

 

         特色：

                   数据流变量，创建变量，绑定值，读取值或者阻塞；

                   轻量级线程；

                   数据流式的流stream，即其尾部是未绑定的数据流变量的列表；

                  确定性计算。

 

         变种：

                   Futures(期货)

                            起源于Multilisp

                            积极/试探的求值

                            实现质量问题

                   I-Structures

                            Id,ph(ParallelHaskell)

                            单次赋值数组

                            不能再绑定值，无stream

 

         Dataflow的不足：

                   不能处理非确定性问题，例如服务器端，需要port实现--像actor的构造。

 

以下的例子取自于Scala 语言的开源项目Akka-（http://akkasource.org），其模拟了Oz语言（http://www.mozart-oz.org）中的数据流并发:

 

// Test5简述：

// 1、创建3个数据流变量x、y和z，其值此时是未绑定的

// 2、创建main线程并启动，绑定x的值1（通过<<运算符）

// 3、获取（通过()调用函数）并比较x与y的值，z会绑定其中的较大者；注意，此时y是//         未绑定的,于是main线程会暂停执行，直到y的值可用（即其它线程给y绑定值）！

// 4、然后，启动另一个线程setY,睡眠5秒后给y绑定值2—这会通知等候y值的main线程，//   --于是比较的代码继续运行，z被绑定为值2！

// 5、最后，关闭3个数据流变量和退出线程。

// 重要的是，无论main与setY哪个先启动或后启动，z的值始终会是期望的较大者2！跟// 上面的actor例子一样，都是无锁(lock-free)即能保证在并发访问下得到期望的结果。

object Test5 extends Application {

 import DataFlow._

 

  valx, y, z = new DataFlowVariable[Int]

  valmain = thread {

         println("Thread'main'")

         x<< 1

         println("'x'set to: " + x())

         println("Waitingfor 'y' to be set...")

         if(x() > y()) {

           z << x

           println("'z' set to 'x': " + z())

         }else {

           z << y

           println("'z' set to 'y': " + z())

        }

        

         x.shutdown

         y.shutdown

         z.shutdown

         v.shutdown

}

 

object Test5 extends Application {

 

  valsetY = thread {

         println("Thread'setY', sleeping...")

         Thread.sleep(5000)

         y<< 2

         println("'y'set to: " + y())

  }

  //shut down the threads

 main ! 'exit

 setY ! 'exit

 System.exit(0)

}

 

// 这个例子就不解释了，有兴趣的读者可以查阅http://github.com/jboner/scala-dataflow

object Test4 extends Application {

 import DataFlow._

 

  defints(n: Int, max: Int, stream: DataFlowStream[Int]): Unit = if (n != max) {

         println("Generatingint: " + n)

         stream<<< n

         ints(n+ 1, max, stream)

  }

  defsum(s: Int, in: DataFlowStream[Int], out: DataFlowStream[Int]): Unit = {

         println("Calculating:" + s)

         out<<< s

         sum(in()+ s, in, out)

  }

  defprintSum(stream: DataFlowStream[Int]): Unit = {

         println("Result:" + stream())

         printSum(stream)

  }

 

  valproducer = new DataFlowStream[Int]

  valconsumer = new DataFlowStream[Int]

 

 thread { ints(0, 1000, producer) }

 thread { sum(0, producer, consumer) }

 thread { printSum(consumer) }

}

九、元组空间Tuplespace

历史：

                   起源于Linda(1984)；

                   流行于Jini。

 

         模型特色：

                   三种操作

                            Write()     (out)

                            Take()       (in)

                            Read()

                   空间解耦

                   时间解耦

                   读取者和写入者解耦

                   数据内容通过模式匹配可编址

                   能够模拟

                            像continuations(延续)的Actor

                            CSP

                            MessagePassing

                            Semaphores

示意图如下：

         问题或不足之处：

                   较低的层次；

                   空间有较高的延迟—空间是竟争点/热点；

                   可伸缩性；

                   相对于并发多用于分布式。

 

 

        

元组空间的进一步介绍，请参阅

《ConcurrentProgramming with Ruby and Tuple Spaces》

http://www.slideshare.net/luccastera/concurrent-programming-with-ruby-and-tuple-spaces

 

十、参考

http://assets.en.oreilly.com/1/event/27/A%20Survey%20of%20Concurrency%20Constructs%20Presentation.pdf