适用于 Java 程序员的 CSP，第 1 部分

适用于 Java 程序员的 CSP ，第 2 部分

在 Java 平台上进行多线程编程是件让人望而生畏的事，这一点得到了广泛认可。实际上，一般的理论似乎是：最好把多线程编程留给 Java 高手。Sun Microsystems 通过（在 EJB 规范中—— 请参阅参考资料）把以下内容描述成 EJB 架构的目标之一，也间接地、更深入地讨论了这个观点：

应用程序开发人员不必理解低级事务和状态管理细节、不必理解多线程、连接池或者其他复杂的低级 API。
如果以这个观念为起点，那么您也就不会惊讶为什么许多 Java 开发人员要避开设计和开发多线程应用程序。但事实上，许多（即使不是大多数）企业级问题使用某种形式的多线程来解决最合适，而 EJB 和类似的框架并不像它们声称的那样，总是最容易的解决方案。

在这篇由三部分组成的系列文章中，我介绍了一个理论，该理论承认了并发编程的复杂性，并且没有试图隐藏这种复杂性，或者使它不那么难于学习和应用。通信顺序进程（Communicating Sequential Processes —— CSP）是一个精确的并发数学理论，可以用来构建多线程应用程序，确保构建的程序中不出现并发的常见问题，而且更重要的是，这一点能够得到证实。

在介绍 CSP 理论和它基于 Java 语言的实现 —— JCSP 库 —— 之前，我希望能够确定我们有一个共同的讨论框架。我先从 Java 平台的并发编程技术概述开始，接着提供了多线程应用程序开发缺陷的深入概述，这些缺陷包括：竞争冒险、死锁、活动锁和资源耗尽等。最后，通过一些具体的讨论结束本文，这些讨论包括为什么 不能像您喜欢的那样验证多线程 Java 应用程序，并确定现有变通方法中您最偏爱的变通方法。
有了这些基础，就可以完全地体会 JCSP 的好处了。这是 Java 平台多线程编程的一个概念性和实践性的解决方案，我将在第 2 部分对其进行探讨，还将在 第 3 部分 探讨 Java 平台上更高级的 CSP 应用程序。

本文假设读者对于 Java 语言的并发编程有一般性的了解，虽然我在文章中也提供了关于这一主题的一个概述。请参阅 参考资料 一节，以获得更详细的信息。

Java 语言的并发编程
就其自身来说，并发编程是一种技术，提供了操作的同时执行，不论是在单一系统上还是分布在大量系统上。这类操作实际是一些指令顺序，例如单独某个顶级任务的子任务，这类操作能够并行执行，或者是作为线程，或者是作为进程。线程和进程之间的本质区别在于：进程通常是独立的（例如独立的地址空间），所以只能通过系统提供的进程间通信机制进行交互，而线程通常共享单一进程的状态信息，能够直接共享系统资源和内存中的对象。

可以使用下面两种方法之一，通过多个进程来实现并发。第一种方法是在同一个处理器上运行进程，由操作系统处理进程之间的上下文环境切换。（可以理解，这种切换要比同一进程内多线程之间的上下文环境切换更慢。）第二种方法是构建大规模的并行和复杂的分布式系统，在不同的物理处理器上运行多个进程。

从内建支持的角度来说，Java 语言通过线程提供并发编程；每个 JVM 都能支持许多线程同时执行。可以用以下两种方法之一在 Java 语言中创建线程：

继承 java.lang.Thread 类。在这种情况下，已经重写的子类的 run() 方法必须包含实现线程运行时行为的代码。要执行这个代码，需要实例化子类对象，然后调用对象的 start() 方法，这样就可以在内部执行 run() 方法了。

创建 Runnable 接口的定制实现。这个接口只包含一个 run() 方法，在这个方法中，要放置应用程序代码。要执行这个代码，需要实例化实现类的对象，然后在创建新 Thread 时，把对象作为构造函数的参数传入。然后调用新创建的线程对象的 start() 方法，开始执行控制的新线程。
线程安全性和同步
如果 Java 对象中的某个方法能够安全地运行在多线程环境中，那么就称该方法是线程安全的。要获得这种安全性，必须有一种机制，通过该机制，运行同一方法的多个线程就能够同步其操作，这样，在访问相同的对象或代码行时，就会只允许一个线程被处理。这种同步要求线程使用叫作 信号 的对象彼此进行沟通。

有一种类型的信号叫作 互斥信号 或互斥体。顾名思义，这个信号对象的拥有权是互斥的，也就是说，在任意指定时间，只有一个线程能够拥有互斥体。其他想获得所有权的线程会被阻塞，它们必须等待，直到拥有互斥体的线程释放互斥体。如果多个线程按顺序排队等候同一互斥体，那么在当前拥有者释放它的时候，只有一个等候线程能够得到它；其他线程将继续阻塞。

在 1970 年代初，C.A.R. Hoare 和其他人共同开发了一个叫作 监视器 的概念（请参阅参考资料）。 一个 监视器就是一个代码主体，它的访问受到互斥体的保护。任何想执行这个代码的线程，都必须在代码块顶部得到关联的互斥体，然后在底部再释放它。因为在指定时间只有一个线程能够拥有互斥体，所以这就有效地保证了只有拥有它的线程才能执行监视器的代码块。（受保护的代码不需要相邻 —— 例如，Java 语言中的每个对象都有一个与之关联的监视器。）

任何想在 Java 语言中进行线程编程的开发人员，都会立即把上面的内容当成 synchronized 关键字所带来的效果。可以确保包含在 synchronized 块中的 Java 代码在指定时间只被一个线程执行。在内部，可以由运行时将 synchronized 关键字转换成某一种情况：所有的竞争线程都试图获得与它们（指线程）正在操作的对象实例关联的那个（惟一的一个）互斥体。成功得到互斥体的线程将运行代码，然后在退出 synchronized 块时释放互斥体。

等候和通知
wait/notify 构造在 Java 语言的线程间通信机制中也扮演了重要的角色。基本的想法是：一个线程需要的某个条件可以由另外一个线程促成。这样，条件的 wait 就可以得到满足。一旦条件为真，那么引发条件的线程就会 notify 等候线程苏醒，并从中止的地方继续进行。

wait/notify 机制要比 synchronized 机制更难理解和判断。要想判断出使用 wait/notify 的方法的行为逻辑，就要求判断出使用它的所有方法的逻辑。一次判断一个方法，把该方法和其他方法隔离开，是对整体系统行为得出错误结论的可靠方式。显然，这样做的复杂性会随着要判断的方法的数量增长而迅速提高。

线程状态
我前面提到过，必须调用新创建的线程的 start() 方法来启动它的执行。但是，仅仅是调用 start() 方法并不意味着线程会立即开始运行。这个方法只是把线程的状态从 new 变成 runnable。只有在操作系统真正安排线程执行的时候，线程状态才会变成 running （从 runnable）。

典型的操作系统支持两种线程模型 —— 协作式和抢占式。在协作式 模型中，每个线程对于自己对 CPU 的控制权要保留多久、什么时候放弃有最终意见。在这个模型中，因为可能存在某个无赖线程占住控制权不放，所以其他线程可能永远无法得到运行。在 抢占式模型中，操作系统本身采用基于时钟“滴答”的计时器，基于这个计时器，操作系统可以强制把控制权从一个线程转移到另外一个线程。在这种情况下，决定哪个线程会得到下一次控制权的调度策略就有可能基于各种指标，例如相对优先级、某个线程已经等待执行的时间长短，等等。

如果出于某些原因，处在 running 状态的线程需要等候某个资源（例如，等候设备的输入数据到达，或者等候某些条件已经设定的通知），或者在试图获得互斥体的时候被阻塞，因此线程决定睡眠，那么这时它可以进入 blocked 状态。当睡眠周期到期、预期输入到达，或者互斥体当前的拥有者将其释放并通知等候线程可以再次夺取互斥体时，阻塞的线程重新进入 runnable 状态。

当线程的 run() 方法完成时（或者正常返回，或者抛出 RuntimeException 这样的未检测到异常），线程将终止。这时，线程的状态是 dead。当线程死亡时，就不能通过再次调用它的 start() 方法来重新启动它，如果那么做，则会抛出 InvalidThreadStateException 异常。

四个常见缺陷
正如我已经展示过的，Java 语言中的多线程编程是通过语言支持的大量精心设计的构造实现的。另外，还设计了大量设计模式和指导原则，来帮助人们了解这种复杂性带来的许多缺陷。除此之外，多线程编程会很容易地在不经意间把细微的 bug 带进多线程代码，而且更重要的是，这类问题分析和调试起来非常困难。接下来要介绍的是用 Java 语言进行多线程编程时将会遇到（或者可能已经遇到过）的最常见问题的一个列表。

争用条件
据说 争用条件存在于这样的系统中：多个线程之间存在对共享资源的竞争，而胜出者决定系统的行为。Allen Holub 在他撰写的文章 “programming Java threads in the real world” （请参阅 参考资料）提供了一个带有这样 bug 的简单的多线程程序示例。在冲突的访问请求之间进行不正确同步的另一个更可怕的后果是数据崩溃，此时，共享的数据结构有一部分由一个线程更新，而另一部分由另一个线程更新。在这种情况下，系统的行为不是按照胜出线程的意图进行，系统根本不按照任何一个线程的意图行动，所以两个线程最后都将以失败告终。

死锁
死锁的情况是指：线程由于等候某种条件变成真（例如资源可以使用），但是它等候的条件无法变成真，因为能够让条件变成真的线程在等候第一个线程“做某件事”。这样，两个线程都在等候对方先采取第一步，所以都无法做事。请参阅 Allen Holub 撰写的文章 （请参阅 参考资料），以获得在多线程 Java 代码中如何发生死锁的示例。

活动锁
活动锁 与 死锁不同，它是在线程实际工作的时候发生的，但这时还没有完成工作。这通常是在两个线程交叉工作的时候发生，所以第一个线程做的工作被另一个线程取消。一个简单的示例就是：每个线程已经拥有了一个对象，同时需要另外一个线程拥有的另外一个对象。可以想像这样的情况：每个线程放下自己拥有的对象，捡起另外一个线程放下的对象。显然，这两个线程会永远都运行在上锁这一步操作上，结果是什么都做不成。（常见的真实示例就是，两个人在狭窄的走廊相遇。每个人都礼貌地让到另一边让对方先行，但却在相同的时间都让到同一边了，所以两个人还都没法通过。这种情况会持续一些时间，然后两个人都从这边闪到那边，结果还是一点进展也没有。）

资源耗尽
资源耗尽，又称为 线程耗尽，是 Java 语言的 wait/notify 原语无法保证 live-ness 的后果。Java 强制这些方法要拥有它们等候或通知的对象的锁。在某个线程上调用的 wait() 方法在开始等候之前必须释放监视器锁，然后在从方法返回并获得通知之后，必须再次重新获得锁。因此，Java 语言规范（请参阅 参考资料）在锁本身之外，还描述了一套与每个对象相关的 等候集（wait set）。一旦线程释放了对象上的锁（在 wait 的调用之后），线程就会放在这个等候集上。

多数 JVM 实现把等候线程放在队列中。所以，如果在通知发生的时候，还有其他线程在等候监视器，那么就会把一个新线程放在队列尾部，而它并不是下一个获得锁的线程。所以，等到被通知线程实际得到监视器的时候，通知该线程的条件可能已经不再为真，所以它不得不再次 wait。这种情况可能无限持续下去，从而造成运算工作上浪费（因为要反复把该线程放入等候集和从中取出）和线程耗尽。

贪心哲学家的寓言
演示这种行为的原型示例是 Peter Welch 教授描述的“聪明人没有鸡肉”（请参阅参考资料）。在这个场景中考虑的系统是一所由五位哲学家、一位厨师和一个食堂组成的学院。所有的哲学家（除了一位）都要想想（在代码示例中，考虑的时间是 3 秒）之后才去食堂取饭。而“贪心的”哲学家则不想把时间浪费在思考上 —— 相反，他一次又一次地回到食堂，企图拿到鸡肉来吃。

厨师按照一批四份的定量准备鸡肉，每准备好一份，就送到食堂。贪心的哲学家不断地去厨房，但他总是错过食物！事情是这样的：他第一次到的时候，时间太早，厨师还没开火。因此贪心的哲学家只好干等着（通过 wait() 方法调用）。在开饭的时候（通过 notify() 方法调用），贪心的哲学家再一次回到食堂排队等候。但是这次，在他前来等候的时候，他的四位同事已经到了，所以他在食堂队列中的位置在他们后面。他的同事把厨房送来的一批四份鸡肉全部拿走了，所以贪心的哲学家又要在一边等着了。 可怜（也可能是公平的） ，他永远处在这个循环之外。

验证的问题
一般来说，很难按照普通的规范对 Java 编程的多线程程序进行验证。同样，开发自动化工具对于常见的并发问题（例如死锁、活动锁和资源耗尽）进行完整而简单的分析也不太容易——特别是在任意 Java 程序中或者在缺乏并发的正式模型的时候。

更糟的是，并发性问题出了名的变化多端、难于跟踪。每个 Java 开发人员都曾经听说过（或者亲自编写过）这样的 Java 程序：经过严格分析，而且正常运行了相当一段时间，没有表现出潜在的死锁。然后突然有一天，问题发生了，结果弄得开发团队经历许多的不眠之夜来试图发现并修补根本原因。

一方面，多线程 Java 程序容易发生的错误非常不明显，有可能在任意什么时候发生。另一方面，完全有可能这些 bug 在程序中从不出现。问题取决于一些不可知的因素。多线程程序的复杂本质，使得人们很难有效地对其进行验证。没有一套现成的规则可以找出多线程代码中的这类问题，也无法确切地证明这些问题不存在，这些导致许多 Java 开发人员完全避开多线程应用程序的设计和开发，即使用并发和并行的方式对系统进行建模会非常棒，他们也不使用多线程。

确实想进行多线程编程的开发人员通常准备好了以下一个或两个解决方案（至少是一部分）：

长时间艰苦地测试代码，找出所有出现的并发性问题，诚心地希望到应用程序真正运行地时候已经发现并修复了所有这类问题。

大量运行设计模式和为多线程编程建立的指导原则。但是，这类指导原则只在整个系统都按照它们的规范设计的时候才有效，没有设计规则能够覆盖所有类型的系统。
虽然知道的人不多，但是对于编写（然后验证）正确的多线程应用程序这一问题，还有第三个选项。使用称为通信顺序进程（ Communicating Sequential Processes，CSP）的精确的线程同步的数学理论，可以在设计时最好地处理死锁和活动锁之类的问题。CSP 由 C.A.R. Hoare 与 20 世纪 70 年代后期设计，CSP 提供了有效的方法，证明用它的构造和工具构建的系统可以免除并发的常见问题。

第 1 部分的结束语
在这份面向 Java 程序员的 CSP 全面介绍的第一部分中，我把重点放在克服多线程应用程序开发常见问题的第一步上，即了解这些问题。我介绍了 Java 平台上目前支持的多线程编程构造，解释了它们的起源，讨论了这类程序可能会有的问题。我还解释了用正式理论在任意的、大型的和复杂的应用程序中清除这些问题（即竞争冒险、死锁、活动锁和资源耗尽）或者证明这些问题不存在的困难。

在 第 2 部分 中，有了这个基本框架在脑子里，我将介绍 CSP 和它基于 Java 的实现 —— JCSP 库。您会发现，CSP 是一个复杂的数学理论，有大量强大的应用程序 （我会在第 3 部分将讨论一些更高级的程序），其中包括多线程编程常见问题的解决方法。

要想了解 JCSP 如何把 CSP 的精华提炼成一个好理解的 Java 构造框架，那么请您现在就跳转至 “第 2 部分：用 JCSP 进行并发编程”。

致谢
我非常感谢 Peter Welch 教授在我编写这个文章系列期间给予的鼓励。他在百忙之中抽出时间，非常细致地审阅了本文的草稿，并提供了许多宝贵的提高本系列质量和准确性的建议。文章中如果还存在错误，那么都是由于我的原因！我在文章中使用的示例基于或来自 JCSP 库的 javadoc 中提供的示例，以及 JCSP Web 站点上提供的 Powerpoint 演示文稿。这两个来源都提供了大量将探索的信息。

参考资料

您可以参阅本文在 developerWorks 全球站点上的 英文原文。

Brian Goetz 撰写的由三部分组成的 “Threading lightly”系列是解决 Java 平台上同步问题的巧妙而系统的方法。（developerWorks，2001 年 7 月）。

Brian 的 Java theory and practice 专栏定期介绍多线程编程。 “并发在一定程度上使一切变得简单 ”（developerWorks，2002 年 11 月）首次研究了 util.concurrent，这是一个广泛采用的用于 Java 平台的并发工具包。

Allen Holub 编程了大量 Java 平台多线程编程的内容。他撰写的“Programming Java threads in the real world” （JavaWorld，1998 年 10 月）提供了线程问题的示例，例如争用条件和死锁。

还请参阅 Holub 有名的苛评“v“ （developerWorks，2000 年 10 月）。

英国坎特伯雷市肯特大学的 Peter Welch 教授设计了“Wot, no chickens?”问题，举例说明 Java 程序中的资源耗尽。

C.A.R. Hoare 开创性的论文“Communicating Sequential Processes”将通信顺序进程的并行组合作为一种基本的编程构造方法进行介绍（Communications of the ACM Archive，1978）。

Hoare 撰写的“Monitors:?an operating system structuring concept” （Communications of the ACM Archive,1974）第一次向全世界介绍了监视器的概念，他采用了非常有表现力的示例，包括单一资源调度器、有边界缓存、闹钟、缓冲池、磁头优化器，以及一个有问题的读取器和写入器版本。

Enterprise JavaBeans 是若干个试图向 Java 程序员隐藏多线程编程复杂性的框架之一。

请参阅 Java Language Specification。

在 developerWorks 的 Java 技术专区 中，可以找到 Java 编程各方面的文章。

请参阅 Developer Bookstore，以获得技术书籍的完整清单，其中包括数百本 Java 相关主题 的书籍。

还请参阅 Java 技术专区教程页，从 developerWorks 获得免费的、以 Java 为重点的教程。

关于作者
Abhijit Belapurkar 从印度德里市的印度理工学院（IIT）获得了计算机科学方面的理工学士学位。在过去的 11 年中，他一直工作在分布式应用程序的架构和信息安全领域，并在使用 Java 平台构建 N-层应用程序方面拥有大约 6 年的经验。他当前在印度班加罗尔市的 Infosys Technologies Limited 担任 J2EE 方面的高级技术架构师。