回到前面例子，查找某个第一次出现的关键字，在屏幕上输出该关键字的位置：

[code]valfirstOccurrence:Future[Int]=Future{

valsource=scala.io.Source.fromFile("myText.txt")

source.toSeq.indexOfSlice("myKeyword")

}

firstOccurrenceonSuccess{

caseidx=>println("Thekeywordfirstappearsatposition:"+idx)

}

firstOccurrenceonFailure{

caset=>println("Couldnotprocessfile:"+t.getMessage)

}

onComplete,、onSuccess和onFailure方法都具有结果类型Unit，这意味着这些回调方法不能被链接。注意，这种设计是为了避免链式调用可能隐含在已注册回调上一个顺序的执行（同一个future中注册的回调是无序的）。

也就是说，我们现在应讨论论何时调用回调。因为回调需要future中的值是可用的，只有future完成后才能被调用。然而，不能保证被完成future的线程或创建回调的线程调用。反而，回调有时会在future对象完成后被某个线程调用。我们可以说，回调最终会被执行。
更进一步，回调被执行的顺序不是预先定义的，甚至在同一个应用程序。事实上，回调也许不是一个接一个连续调用的，但在同一时间并发调用。这意味着，下面例子中，变量totalA也许不能从计算的文本中得到大小写字母数量的正确值。

[code]@volatilevartotalA=0

valtext=Future{

"na"*16+"BATMAN!!!"

}

textonSuccess{

casetxt=>totalA+=txt.count(_=='a')

}

textonSuccess{

casetxt=>totalA+=txt.count(_=='A')

}

上面，两个回调可能一个接一个地执行，变量totalA得到的预期值为18。然而，它们也可能是并发执行，于是，totalA最终可能是16或2，因为+=不是一个原子操作（即它是由一个读和一个写的步骤组成，这样就可能使其与其他的读和写任意交错执行）。

考虑到完整性，回调的语义如下：

在future上注册onComplete回调，要确保future执行完成后，相应的闭包（closure）最终被调用。
注册onSuccess或onFailure回调，与onComplete语义一样，不同的是，只有在future成功地或失败地执行完后，才会调用。
在future上注册一个已经完成的回调，将导致回调最终被执行。将最终导致一直处于执行状态的回调（上面1所隐含的）。
在future上注册多个回调时，这些回调的执行顺序是不确定的。事实上，这些回调可能是并行执行的，然而，某个ExecutionContext执行可能导致明确的执行顺序。
在某些回调抛出异常时，其他回调的执行不受影响。
在某些回调无法永远无法结束时（例如，回调包含一个无限循环），其他回调可能完全不会执行。这种情况下，那些潜在的阻塞的回调需要使用阻塞结构。将在后面“阻塞”小节说明。
一旦执行完后，回调会从future对象中移除，这对垃圾回收机制（GC）很合适。

函数组合(FunctionalComposition)和For解构(For-Comprehensions)

尽管前文所展示的回调机制已经足够把future的结果和后继计算结合起来的，但是有时回调机制并不易于使用，且容易造成冗余的代码。可以通过一个例子来说明。假设，我们有一个用于进行货币交易服务的API，想要在有盈利的时候购进一些美元。让我们先来看看怎样用回调来解决这个问题：

[code]valrateQuote=Future{

connection.getCurrentValue(USD)

}

rateQuoteonSuccess{casequote=>

valpurchase=Future{

if(isProfitable(quote))connection.buy(amount,quote)

elsethrownewException("notprofitable")

}

purchaseonSuccess{

case_=>println("Purchased"+amount+"USD")

}

}

首先，我们创建一个名为rateQuote的future对象并获得当前的汇率。从服务器返回汇率且该future对象成功完成之后，在onSuccess回调判断买还是不买。所以，我们创建了另一个名为purchase的future对象，用来在可盈利的情况下做出购买决定，并在发送一个请求。最后，一旦purchase运行结束，会输出一条通知消息。

这确实是可行，但有两点原因使这种做法并不方便。其一，不得不使用onSuccess，且不得不在其中嵌套另一个purchasefuture对象。试想一下，如果在purchase执行完成之后我们可能想要卖掉一些其他的货币。这时将不得不在onSuccess的回调中重复这个模式，从而可能使代码过度嵌套，冗长且难以理解。

其二，purchase只是定义在局部范围，只能被来自onSuccess内部的回调响应。也就是说，这个应用的其他部分看不到purchase，而且不能为它注册其他的onSuccess回调，比如说卖掉些其他货币。

为解决上述的两个问题，futures提供了组合器（combinators）使之具有更多易用的组合。映射（map）是最基本的组合器之一。试想，给定一个future对象和一个通过映射来获得该future值的函数，映射方法将创建一个新Future对象，一旦原来的Future成功完成了计算，新Future会通过该返回值来完成自己的计算。你能够像理解容器(collections)的map一样来理解future的map。

让我们用map的方法来重构一下前面的例子：

[code]valrateQuote=Future{

connection.getCurrentValue(USD)

}

valpurchase=rateQuotemap{quote=>

if(isProfitable(quote))connection.buy(amount,quote)

elsethrownewException("notprofitable")

}

purchaseonSuccess{

case_=>println("Purchased"+amount+"USD")

}

通过对rateQuote的映射我们减少了一次onSuccess回调，更重要的是避免了嵌套。这时如果我们决定出售一些货币就可以再次使用purchase方法上的映射了。

可是，如果isProfitable方法返回了false将会发生些什么？会引发异常？这种情况下，purchase的确会因异常而失败。不仅仅如此，想象一下，链接的中断和getCurrentValue方法抛出异常会使rateQuote的操作失败。在这些情况下，映射将不会返回任何值，而purchase也会自动以和rateQuote相同的异常而执行失败。

总之，如果原Future的计算成功完成了，那么返回的Future将会使用原Future的映射值来完成计算。如果映射函数抛出了异常，则Future也会带着该异常完成计算。如果原Future由于异常而计算失败，那么返回的Future也会包含相同的异常。这种异常的传导方式也同样适用于其他的组合器(combinators)。

Future的这个设计目的是使之能够在For-comprehensions下使用。也正是因为这，Future还拥有flatMap，filter和foreach等组合器。其中，flatMap方法可以构造一个函数，可以把值映射到一个姑且称为g的新future，然后返回一个随g的完成而完成的Future对象。

让我们假设，想把一些美元兑换成法郎。必须为这两种货币报价，然后再在这两个报价的基础上确定交易。下面是一个在for-comprehensions中使用flatMap和withFilter的例子：

[code]valusdQuote=Future{connection.getCurrentValue(USD)}

valchfQuote=Future{connection.getCurrentValue(CHF)}

valpurchase=for{

usd<-usdQuote

chf<-chfQuote

ifisProfitable(usd,chf)

}yieldconnection.buy(amount,chf)

purchaseonSuccess{

case_=>println("Purchased"+amount+"CHF")

}

purchase只有当usdQuote和chfQuote都完成计算后才能完成，它以其他两个Future的计算值为前提，所以它自己的计算不能更早开始。

上面的for-comprhension将被转换为：

[code]valpurchase=usdQuoteflatMap{

usd=>

chfQuote

.withFilter(chf=>isProfitable(usd,chf))

.map(chf=>connection.buy(amount,chf))

}

这的确是比for-comprehension稍微难以把握一些，但是我们这样分析有助于更容易的理解flatMap操作。FlatMap操作会把自身的值映射到其他future对象上，并随着该对象计算完成的返回值一起完成计算。在例子中，flatMap用usdQuote的值把chfQuote的值映射到第三个futrue对象里，该对象用于发送一定量法郎的购入请求。只有当通过映射返回的第三个future对象完成了计算，purchase才能完成计算。

这可能有些难以置信，但幸运的是faltMap操作在for-comprhensions模式以外很少使用，因为for-comprehensions本身更容易理解和使用。

再说说filter，它可以用于创建一个新的future对象，该对象只有在满足某些特定条件的前提下才会得到原始future的计算值，否则就会抛出一个NoSuchElementException的异常而失败。调用了filter的future，其效果与直接调用withFilter完全一样。

collect和filter组合器之间的关系有些类似容器（collections）API里那些方法之间的关系。

值得注意的是，调用foreach组合器并不会在计算值可用的时候阻塞当前的进程去获取计算值。恰恰相反，只有当future对象成功计算完成后，foreach所迭代的函数才能够被异步执行。这意味着foreach与onSuccess回调意义完全相同。

由于Futuretrait（trait类似java中的接口interface）从概念上看包含两种类型的返回值（计算结果和异常），所以组合器会有一个处理异常的需求。

比如，我们准备在rateQuote的基础上决定购入一定量的货币，那么

connection.buy

方法需要知道购入的数量和期望的报价值，最终完成购买的数量将会被返回。假如报价值偏偏在这个时候改变了，那么，buy方法将会抛出一个

QuoteChangedExecption

，并且不会做任何交易。如果我们想让我们的Future对象返回0，而不是抛出那个该死的异常，那我们需要使用recover组合器：

[code]valpurchase:Future[Int]=rateQuotemap{

quote=>connection.buy(amount,quote)

}recover{

caseQuoteChangedException()=>0

}

recover能够创建一个新future对象，该对象当计算完成时持有和原future对象一样的值。如果执行不成功，则偏函数的参数会被传递给使原Future失败的那个Throwable异常。如果它把Throwable映射到了某个值，那么新的Future就会成功完成并返回该值。如果偏函数没有定义在Throwable中，那么最终产生结果的future也会失败并返回同样的Throwable。

组合器recoverWith能够创建一个新future对象，当原future对象成功完成计算时，新future对象包含有和原future对象相同的计算结果。若原future失败或异常，偏函数将会返回造成原future失败的相同的Throwable异常。如果此时Throwable又被映射给了别的future，那么新Future就会完成并返回这个future的结果。recoverWith和recover的关系与flatMap和map之间的关系很像。

fallbackTo组合器生成的future对象可以在该原future成功完成计算时返回结果，如果原future失败或异常返回future参数对象的成功值。在原future和参数future都失败的情况下，新future对象会完成并返回原future对象抛出的异常。正如下面例子，本想打印美元的汇率，但在获取美元汇率失败的情况下会打印法郎的汇率：

[code]valusdQuote=Future{

connection.getCurrentValue(USD)

}map{

usd=>"Value:"+usd+"$"

}

valchfQuote=Future{

connection.getCurrentValue(CHF)

}map{

chf=>"Value:"+chf+"CHF"

}

valanyQuote=usdQuotefallbackTochfQuote

anyQuoteonSuccess{println(_)}

组合器andThen的用法是出于纯粹的side-effecting目的。经andThen返回的新Future，无论原Future成功或失败都会返回与原Future一样的结果。一旦原Future完成并返回结果，andThen后跟的代码块就会被调用，且新Future将返回与原Future一样的结果，这确保了多个andThen调用的顺序执行。正如下例所示，这段代码可以从社交网站上把近期发出的帖子收集到一个可变集合里，然后把它们都打印在屏幕上：

[code]valallposts=mutable.Set[String]()

Future{

session.getRecentPosts

}andThen{

posts=>allposts++=posts

}andThen{

posts=>

clearAll()

for(post<-allposts)render(post)

}

综上所述，Future的组合器功能是纯函数式的，每种组合器都会返回一个与原Future相关的新Future对象。

投影（Projections）

为了确保for-comprehensions能够返回异常，futures也提供了投影(projections)。如果原future对象失败了，失败的投影(projection)会返回一个带有Throwable类型返回值的future对象。如果原Future成功了，失败的投影(projection)会抛出一个NoSuchElementException异常。下面是一个在屏幕上打印出异常的例子：

[code]valf=Future{

2/0

}

for(exc<-f.failed)println(exc)

下面例子不会在屏幕上打印出任何东西：

[code]valf=Future{

4/2

}

for(exc<-f.failed)println(exc)

Future扩展

更多的实用方法对FuturesAPI进行了扩展支持，这将为很多外部框架提供更多专业工具。

阻塞

future一般都是异步的，不会阻塞潜在的执行线程。然而，在某些情况下，阻塞是必要的。我们区分了两种阻塞执行线程的形式：future内的阻塞，以及future外的阻塞，等待直到future完成。

Future内的阻塞

Asseenwiththeglobal

ExecutionContext

,itispossibletonotifyan

ExecutionContext

ofablockingcallwiththe

blocking

construct.Theimplementationishoweveratthecompletediscretionofthe

ExecutionContext

.Whilesome

ExecutionContext

suchas

ExecutionContext.global

implement

blocking

bymeansofa

ManagedBlocker

,someexecutioncontextssuchasthefixedthreadpool:

正如全局ExecutionContext，它可以通知一个具有阻塞结构的阻塞调用的ExecutionContext。然而，实现是很慎重的。当某些ExecutionContext通过ManagedBlocker实现阻塞，一些执行上下文，如固定的线程池：

[code]ExecutionContext.fromExecutor(Executors.newFixedThreadPool(x))

下面代码将什么都不做：

[code]implicitvalec=ExecutionContext.fromExecutor(

Executors.newFixedThreadPool(4))

Future{

blocking{blockingStuff()}

}

下面效果一样：

[code]Future{blockingStuff()}

阻塞的代码也可能抛出异常。在这种情况下，这个异常会转发给调用者。

future外阻塞

正如前面所说，在future上阻塞是不鼓励的，因为会出现性能和死锁。回调（Callbacks）和组合器（combinators）才是首选方法，但在某些情况中阻塞也是需要的，并且Futures和PromisesAPI也支持。

在之前的并发交易例子中，在最后有一处用到阻塞来确定是否所有的futures都已完成。下面是如何使用block来处理一个future结果的例子：

[code]importscala.concurrent._

importscala.concurrent.duration._

defmain(args:Array[String]){

valrateQuote=Future{

connection.getCurrentValue(USD)

}

valpurchase=rateQuotemap{quote=>

if(isProfitable(quote))connection.buy(amount,quote)

elsethrownewException("notprofitable")

}

Await.result(purchase,0nanos)

}

在这种情况下，future失败了，调用者转发出了该future失败的异常。它包含了失败的投影(projection)——阻塞该结果，将会造成一个NoSuchElementException异常，若原future对象被成功完成。

相反的，调用

Await.ready

来等待，知道这个future完成，但获不到结果。同样，如果future失败，调用不会抛出异常的方法。

Futuretrait用

ready()

和

result()

方法实现了Awaitabletrait。这些方法不能被客户端直接调用——它们只能被执行上下文调用。

异常

当异步计算抛出未处理的异常时，与那些计算相关的futures就失败了。失败的futures存储了一个Throwable的实例，而不是返回值。Futures提供onFailure回调方法，它用一个PartialFunction去表示一个Throwable。下列特殊异常的处理方式不同：

scala.runtime.NonLocalReturnControl[_]

–此异常保存了一个与返回相关联的值。通常情况下，在方法体中的返回结构被调用去抛出这个异常。相关联的值将会存储到future或一个promise中，而不是一直保存在这个异常中。

ExecutionException-当因为一个未处理的中断异常、错误或者

scala.util.control.ControlThrowable

导致计算失败时会被存储起来。这种情况下，ExecutionException会为此具有未处理的异常。这些异常会在执行失败的异步计算线程中重新抛出。这样做的目的，是为了防止正常情况下没有被客户端代码处理过的那些关键的、与控制流相关的异常继续传播下去，同时告知客户端其中的future对象是计算失败的。

更精确的语义描述请参见[NonFatal]。

Promises

到目前为止，我们仅考虑了通过异步计算的方式创建future对象来使用future的方法。尽管如此，futures也可以使用promises来创建。
如果说futures是为了一个还没有存在的结果，而当成一种只读占位符的对象类型去创建，那么promise就被认为是一个可写的，可以实现一个future的单一赋值容器。这就是说，promise通过这种success方法可以成功去实现一个带有值的future。相反的，因为一个失败的promise通过failure方法就会实现一个带有异常的future。
一个promisep通过p.future方式返回future。这个futrue对象被指定到promisep。根据这种实现方式，可能就会出现p.future与p相同的情况。
考虑下面的生产者-消费者的例子，其中一个计算产生一个值，并把它转移到另一个使用该值的计算。这个传递中的值通过一个promise来完成。

[code]importscala.concurrent.{future,promise}

importscala.concurrent.ExecutionContext.Implicits.global

valp=promise[T]

valf=p.future

valproducer=future{

valr=produceSomething()

psuccessr

continueDoingSomethingUnrelated()

}

valconsumer=future{

startDoingSomething()

fonSuccess{

caser=>doSomethingWithResult()

}

}

这里，我们创建了一个promise，并利用它的future方法获得一个Future。然后，开始两个异步计算。第一种，做些计算，将结果放在r中，通过执行promisep，这个值被用来完成future对象f。第二个，也做某写计算，然后读取实现了futuref的计算结果值r。注意，在生产者完成执行

continueDoingSomethingUnrelated()

方法之前，消费者可以获得这个结果值。

正如前面提到的，promises具有单赋值语义。因此，它们仅能被实现一次。在一个已经计算完成的promise或者failed的promise上调用success方法将会抛出一个IllegalStateException异常。

下面例子显示了如何失败一个promise。

[code]valp=promise[T]

valf=p.future

valproducer=future{

valr=someComputation

if(isInvalid(r))

pfailure(newIllegalStateException)

else{

valq=doSomeMoreComputation(r)

psuccessq

}

}

如上，生产者计算出一个中间结果r，并判断它的有效性。如果无效，它会通过返回一个异常实现promisep的方式失败这个promise，关联的futuref是failed。否则，生产者会继续它的计算，最终使用一个有效的结果值实现futuref，同时实现promisep。

Promises也能通过一个complete方法来实现，这个方法采用了一个

potentialvalueTry[T]

，这个值要么是一个类型为

Failure[Throwable]

的失败结果，要么是一个类型为

Success[T]

的成功结果。

类似success方法，在一个已经完成的promise对象上调用failure和complete方法同样会抛出一个IllegalStateException异常。

前面所述的promises和futures方法的一个优点是，这些方法是单一操作的，并且是没有副作用（side-effects）的，因此程序是确定性的（deterministic）。确定性意味着，如果该程序没有抛出异常（future的计算值被获得），无论并行的程序如何调度，那么程序的结果将会永远是一样的。

在一些情况下，客户端也许希望能够只在promie没有完成的情况下完成该promise的计算（例如，如果有多个HTTP请求被多个不同的futures对象来执行，并且客户端只关心一个HTTP应答，该应答对应于第一个完成该promise的future）。因此，future提供了tryComplete，trySuccess和tryFailure方法。客户端需要意识到调用这些的结果是不确定的，调用的结果将依赖程序的调度。

completeWith方法将用另外一个future完成promise计算。当该future结束的时候，该promise对象得到那个future对象同样的值，如下的程序将打印1：

[code]valf=future{1}

valp=promise[Int]

pcompleteWithf

p.futureonSuccess{

casex=>println(x)

}

当让一个promise以异常失败的时候，三种子类型的Throwable异常被分别的处理。如果中断该promise的可抛出(Throwable)一场是

scala.runtime.NonLocalReturnControl

，那么该promise将以对应的值结束；如果是一个Error的实例，

InterruptedException

或者

scala.util.control.ControlThrowable

，那么该可抛出(Throwable)异常将会封装一个ExecutionException异常，该ExectionException将会让该promise以失败结束。

通过使用promises，futures的onComplete方法和future的构造方法，你能够实现前文描述的任何函数式竞争组合器（compitioncombinators）。假设，你想实现一个新的组合器，该组合器首先使用两个future对象f和g，并产生第三个future，该future是通过f或者g完成的，但只在成功完成的情况下。

下面是关于这个的例子：

[code]deffirst[T](f:Future[T],g:Future[T]):Future[T]={

valp=promise[T]

fonSuccess{

casex=>p.trySuccess(x)

}

gonSuccess{

casex=>p.trySuccess(x)

}

p.future

注意，在这种实现方式中，如果f与g都不成功，那么

first(f,g)

将永远不会完成（即返回一个值或者返回一个异常）。

工具(Utilities)

为了简化在并发应用中处理时序的问题，

scala.concurrent

引入了Duration抽象。Duration不是被作为另外一个通常的时间抽象存在的。他是为了用在并发库中，Duration位于

scala.concurrent

包中。

Duration是表示时间长短的基础类，其可以是有限的或者无限的。有限的duration用FiniteDuration类来表示，并通过时间长度

(length)

和

java.util.concurrent.TimeUnit

来构造。无限的durations，同样扩展了Duration，只在两种情况下存在，

Duration.Inf

和

Duration.MinusInf

。库中同样提供了一些Durations的子类用来做隐式的转换，这些子类不应被直接使用。

抽象的Duration类包含了如下方法：

转换到不同的四件单位（toNanos,toMicros,toMillis,toSeconds,toMinutes,toHours,toDaysandtoUnit(unit:TimeUnit)）；
durations比较（<,<=,>和>=）；
算术运算符（+,-,*,/和unary_-）；
Minimumandmaximumbetweenthisdurationandtheonesuppliedintheargument(min,max).
检查duration是否无限（isFinite）。

Duration能够用如下方法实例化（

instantiated）：

隐式的通过Int和Long类型转换得来

vald=100millis

。
通过传递一个

Longlength

和

java.util.concurrent.TimeUnit

。例如

vald=Duration(100,MILLISECONDS)

。
通过传递一个字符串来表示时间区间，例如

vald=Duration("1.2µs")

。

Duration也提供了unapply方法，可以被用于模式匹配构造（patternmatchingconstructs）中，例如：

[code]importscala.concurrent.duration._

importjava.util.concurrent.TimeUnit._

//instantiation

vald1=Duration(100,MILLISECONDS)//fromLongandTimeUnit

vald2=Duration(100,"millis")//fromLongandString

vald3=100millis//implicitlyfromLong,IntorDouble

vald4=Duration("1.2µs")//fromString

//patternmatching

valDuration(length,unit)=5millis

参考资料

ScalaGuidesandOverviews