Java 下一代: Clojure 中的并发性

Clojure 如何抽象并发性和共享状态

Clojure 拥有所有 Java 下一代语言中最激进的并发性方法。本期深入探讨 Clojure 中的并发性的一些方面,包括 epochal 时间模型软件事务内存

Neal Ford, 主管 / 软件架构师 / Meme Wrangler , ThoughtWorks Inc.

Photo of Neal FordNeal Ford 是一家全球性的 IT 咨询公司 ThoughtWorks 的主管、软件架构师和 Meme Wrangler。他还设计并编写了一些应用程序、教材、杂志文章、课件和视频/DVD演示文稿,他是多种技术书籍的作者或编辑,其中包括最近出版的这本 Presentation Patterns。他的工作重点是设计和构建大型企业级应用程序。他还是全球范围开发者大会上的一位国际知名的演讲者。您可以查看 他的网站



2014 年 6 月 16 日

关于本系列

Java™ 传承的是平台,而不是语言。有超过 200 种语言可以在 JVM 上运行,它们之中不可避免地会有一种语言最终取代 Java 语言,成为编写 JVM 程序的最佳方式。本系列将探讨三种下一代 JVM 语言:Groovy、Scala 和 Clojure,比较并对比新的功能和范例,让 Java 开发人员对自己近期的未来发展有大体的认识。

在所有 Java 下一代语言中,Clojure 拥有最激进的并发性机制和功能。Groovy 和 Scala 都为并发性提供了改善的抽象和语法糖的一种组合,而 Clojure 坚持了它始终在 JVM 上提供独一无二的行为的强硬立场。在本期 Java 下一代 中,我将介绍 Clojure 中众多并发性选项的一部分。首先是为 Clojure 中易变的引用提供支撑的基础抽象:epochal 时间模型

Epochal 事件模型

或许 Clojure 与其他语言最显著的区别与易变的状态和 密切相关。Clojure 中的 可以是任何用户感兴趣的数据:数字 42、映射结构 {:first-name "Neal :last-name "Ford"} 或某些更大型的数据结构,比如 Wikipedia。基本来讲,Clojure 语言对待所有值就像其他语言对待数字一样。数字 42 是一个值,您不能重新定义它。但可对该值应用一个函数,返回另一个值。例如,(inc 42) 返回值 43

在 Java 和其他基于 C 的语言中,变量 同时持有身份和值,这是让并发性在 Java 语言中如此难以实现的因素之一。语言设计人员在线程抽象之前创建了变量抽象,变量的设计没有考虑为并发性增加的复杂性。因为 Java 中的变量假设只有单个线程,所以在多线程环境中,需要像同步块这样麻烦的机制来保护变量。Clojure 的设计人员 Rich Hickey 让交织(complect) 这个古老的词汇恢复了活力(交织这个词被定义为 “缠绕或编织”),用于描述 Java 变量中的设计缺陷。

Clojure 将引用 分开。在 Clojure 世界观中,数据以一系列不变的值的形式存在,如图 1 所示。

图 1. epochal 时间模型中的值
该图演示了 epochal 时间模型中的值

图 1 显示,像 v1 这样的独立的值表示 42 或 Wikipedia 等数据,使用方框表示。与值独立的是函数,它们获取值作为参数并生成新值,如图 2 所示。

图 2. epochal 时间模型中的函数
该图演示了 epochal 时间模型中的函数

图 2 将函数显示为与值独立的圆圈。函数调用会生成新值,使用值作为参数和结果。一连串的值保存在一个引用 中,它表示变量的身份。随着时间的推移,此身份可能指向不同的值(由于函数应用),但身份从不更改,如图 3 中的虚线所示。

图 3. epochal 时间模型中的引用
该图演示了 epochal 时间模型中的引用

在图 3 中,整幅图表示一个引用随时间的变化。虚线是一个引用,它持有其生存期内的一连串的值。可在某个时刻向引用分配一个新的不变值;引用指向的目标可更改,而无需更改该引用。

在引用的生存期中,一个或多个观察者(其他程序、用户界面、任何对该引用持有的值感兴趣的对象)将解除引用它,查看它的值(或许还执行某种操作),如图 4 所示。

图 4. 解除引用
该图演示了解除引用

在图 4 中,观察者(有两种楔形表示)可持有引用本身(由来自虚线引用的箭头表示),或者可解除引用它,检索它的值(由来自该值的箭头表示)。例如,您可能有一个函数,它以一个传递给您的数据库连接作为参数,您进而将该参数传递给一个更低级的持久性函数。在此情况下,您持有该引用,但从不需要它的值;持久性函数可能会解除引用它,以获取它的值来连接到一个数据库。

请注意,图 4 中的观察者不会进行协调 — 它们完全不依赖彼此。此结构使得 Clojure 运行时能够在整个语言中保证了一些有用的属性,比如决不允许读取程序阻塞,这使得读取操作变得非常高效。如果您希望更改一个引用(也就是说,将它指向一个不同的值),可使用 Clojure 的一个 API 来执行更新,这会采用 epochal 时间模型。

epochal 时间模型为整个 Clojure 中的引用更新提供了支持。因为运行时控制所有更新,所以它可防御线程冲突,开发人员在不太复杂的语言中必须争用线程。

Clojure 拥有广泛的方式来更新引用,具体依赖于您想要何种特征。接下来,我将讨论两种方式:简单的原子 和复杂的软件事务内存

原子

Clojure 中的原子 是对数据一个原子部分的引用,无论该部分有多大。您创建一个 atom 并初始化它,然后应用一个突变函数。这里,我为一个原子创建了一个称为 counter 的引用,将它初始化为 0。如果我希望将引用更新到一个新值,我可使用 (swap!) 这样的函数,它原子化地为该引用换入一个新值:

(def counter  (atom 0))
(swap! counter + 10)

根据 Clojure 中的惯例,突变函数的名称以一个感叹号结尾。(swap!) 函数接受该引用、要应用的函数(在本例中为 + 运算符)和任何其他参数。

Clojure 原子持有任何大小的数据,而不只是原始值。例如,我可围绕一个 person 映射创建一个原子引用,并使用 map 函数更新它。使用 (create-person) 函数(未显示),我在一个原子中创建一个 person 记录,然后使用 (swap!)(assoc ) 更新该引用,这会更新一个映射关联:

(def person (atom (create-person)))
(swap! person assoc :name "John")

原子还会通过 (compare-and-set!) 函数,使用原子实现一个通用的乐观锁定模式:

(compare-and-set! a 0 42)
=> false

(compare-and-set! a 1 7)
= true

(compare-and-set!) 函数接受 3 个参数:原子引用、想要的现有值和新值。如果原子的值与想要的值不匹配,更新不会发生,函数会返回 false

Clojure 有各种各样的机制都遵循引用语义。例如,promise(是一种不同的引用)承诺在以后提供一个值。这里,我创建对一个名为 number-later 的 promise 的引用。此代码不会生成任何值,就像它对最终会这么做的承诺一样。调用 (deliver ) 函数时,一个值会绑定到 number-later

(def number-later (promise))
(deliver number-later 42)

尽管此示例使用了 Clojure 中的 futures 库,但引用语义与简单的原子保持一致。

软件事务内存

没有其他任何 Clojure 特性获得了比软件事务内存 (STM) 更多的关注,这是 Clojure 以 Java 语言封装垃圾收集的方式来封装并发性的内部机制。换句话说,您可编写高性能的多线程 Clojure 应用程序,而从不考虑同步块、死锁、线程库等。

Clojure 封装并发性的方式是,通过 STM 控制引用的所有突变。更新一个引用(惟一的易变抽象)时,必须在一个事务中执行,以使 Clojure 运行时能够管理更新。考虑一个经典的银行问题:向一个帐户中存款,同时向另一个帐户贷款。清单 1 显示了一个简单的 Clojure 解决方案。

清单 1. 银行交易
(defn transfer
  [from to amount]
  (dosync
   (alter from - amount)
   (alter to + amount)))

清单 1 中,我定义了一个 (transfer ) 函数,它接受 3 个参数:fromto 帐户 — 二者都是引用 — 以及金额。我从 from 帐户中减去该金额,将它添加到 to 帐户中,但此操作必须与 (dosync ) 事务一起发生。如果我在事务块的外部尝试一个 (alter ) 调用,更新会失败并抛出一个 IllegalStateException

(alter from - 1)
=>> IllegalStateException No transaction running

清单 1 中,(alter ) 函数仍然遵守 epochal 时间模型,但使用 STM 来确保两个操作都完成或都未完成。为此,STM — 非常像一个数据库服务器 — 临时重试阻塞的操作,所以您的更新函数在更新之外不应有任何副作用。例如,如果您的函数还写入一个日志,由于不断重试,您可能会看到多个日志条目。STM 还会随未解决事务的时长增长而逐步提高它们的优先级,显示数据库引擎中的其他更常见的行为。

STM 的使用很简单,但底层机制很复杂。从名称可以看出,STM 是一个事务系统。STM 实现了 ACID 事务标准的 ACI 部分:所有更改都是原子性一致隔离的。ACID 的耐久 部分在这里不适用,因为 STM 在内存中操作。很少看到将像 STM 这样的高性能机制内置于一种语言的核心中;Haskell 是惟一认真实现了 STM 的另一种主流语言 — 不要奇怪,因为 Haskell(像 Clojure 一样)非常喜欢不变性。(.NET 生态系统曾尝试构建一个 STM 管理器,但最终放弃了,因为处理事务和不变性变得太复杂了。)


缩减程序(reducer)和数字分类

如果不讨论 上一期 中的数字分类器问题的替代实现,并行性介绍都是不完整的。清单 2 显示了一个没有并行性的原子版本。

清单 2. Clojure 中的数字分类器
(defn classify [num]
  (let [facts (->> (range 1 (inc num))
           (filter #(= 0 (rem num %))))
   sum (reduce + facts)
      aliquot-sum (- sum num)]
         (cond
         (= aliquot-sum num) :perfect
         (> aliquot-sum num) :abundant
         (< aliquot-sum num) :deficient)))

清单 2 中的分类器版本浓缩为单个函数,它返回一个 Clojure 关键字(由一个前导冒号表示)。(let ) 块使我能够建立局部绑定。为了确定因数,我使用 thread-last 运算符来过滤数字范围,让代码更有序。sumaliquot-sum 的计算都很简单;一个数字的真因数和 是它的因数之和减去它本身,这使我的比较代码更简单。该函数的最后一行是 (cond ) 语句,它针对计算的值来计算 aliquot-sum,返回合适的关键字枚举。此代码的一个有趣之处是,我以前的实现中的方法在这个版本中折叠为简单的赋值。在计算足够简单和简洁时,您通常需要创建的函数更少。

Clojure 包含一个称为 缩减程序 的强大的并发性库。(有关缩减程序库的开发过程的解释 — 包括为利用最新的 JVM 原生的 fork/join 工具而进行的优化 — 是一个吸引人的故事。)缩减程序库提供了常见运算的就地替换,比如 mapfilterreduce,使这些预算能够自动利用多个线程。例如,将标准的 (map ) 替换为 (r/map )r/ 是缩减程序的命名空间),会导致您的映射操作自动被运行时并行化。

清单 3 给出了一个利用了缩减程序的数字分类器版本。

清单 3. 使用了缩减程序库的分类器
(ns pperfect.core
  (:require [clojure.core.reducers :as r]))

(defn classify-with-reducer [num]
  (let [facts (->> (range 1 (inc num))
		   (r/filter #(= 0 (rem num %))))
	sum (r/reduce + facts)
	    aliquot-sum (- sum num)]
               (cond
               (= aliquot-sum num) :perfect
               (> aliquot-sum num) :abundant
               (< aliquot-sum num) :deficient)))

必须仔细观察,才能找出 清单 2清单 3 之间的区别。惟一的区别是引入了缩减程序命名空间和别名,向 filterreduce 都添加了 r/。借助这些细微的更改,我的过滤和缩减操作现在可自动使用多个线程。


结束语

本期介绍了 Clojure 中的一些并发性选项,这是一个内容丰富的主题区域。我讨论了核心的底层抽象 — epochal 时间模型 — 展示了原子和 STM 如何使用此概念。我还演示了一种简单的就地替换库,它使现有的应用程序能够使用高级并发性功能,比如 fork/join。

Clojure 中还有其他许多并发性选项,包括更简单的并行函数,比如 pmap (parallel map)。Clojure 还包含代理 — 绑定到一个池中的线程上的自主工作者(由系统或用户定义),与 Scala 的 actor 大体相似。Clojure 还融入了 Java 语言中所有现在的并发性进步,使它能轻松地使用 fork/join 等现代库。

或许比任何其他 Clojure 特性都更明显,并发性工具显示了 Clojure 生态系统的工程设计重点:充分利用语言特性来构建强大的抽象。Clojure 没有尝试创建一个 Lispy 版的 Java。设计者从根本上重新思考了核心基础设施和实现。

在下一期中,我将介绍 Java 下一代语言中的 Java 8。

参考资料

学习

讨论

  • 加入 developerWorks 中文社区。探索由开发人员推动的博客、论坛、群组和维基,并与其他 developerWorks 用户进行交流。

条评论

developerWorks: 登录

标有星(*)号的字段是必填字段。


需要一个 IBM ID?
忘记 IBM ID?


忘记密码?
更改您的密码

单击提交则表示您同意developerWorks 的条款和条件。 查看条款和条件

 


在您首次登录 developerWorks 时,会为您创建一份个人概要。您的个人概要中的信息(您的姓名、国家/地区,以及公司名称)是公开显示的,而且会随着您发布的任何内容一起显示,除非您选择隐藏您的公司名称。您可以随时更新您的 IBM 帐户。

所有提交的信息确保安全。

选择您的昵称



当您初次登录到 developerWorks 时,将会为您创建一份概要信息,您需要指定一个昵称。您的昵称将和您在 developerWorks 发布的内容显示在一起。

昵称长度在 3 至 31 个字符之间。 您的昵称在 developerWorks 社区中必须是唯一的,并且出于隐私保护的原因,不能是您的电子邮件地址。

标有星(*)号的字段是必填字段。

(昵称长度在 3 至 31 个字符之间)

单击提交则表示您同意developerWorks 的条款和条件。 查看条款和条件.

 


所有提交的信息确保安全。


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=Java technology, Open source
ArticleID=974534
ArticleTitle=Java 下一代: Clojure 中的并发性
publish-date=06162014