【Akka】在併發程序中使用Future

引言

在Akka中, 一個Future是用來獲取某個併發操作的結果的數據結構。這個操作通常是由Actor執行或由Dispatcher直接執行的. 這個結果可以以同步（阻塞）或異步（非阻塞）的方式訪問。
Future提供了一種簡單的方式來執行並行算法。

Future直接使用

Future中的一個常見用例是在不需要使用Actor的情況下併發地執行計算。
Future有兩種使用方式：

1. 阻塞方式（Blocking）：該方式下，父actor或主程序停止執行知道所有future完成各自任務。通過scala.concurrent.Await使用。
2. 非阻塞方式（Non-Blocking），也稱爲回調方式（Callback）：父actor或主程序在執行期間啓動future，future任務和父actor並行執行，當每個future完成任務，將通知父actor。通過onComplete、onSuccess、onFailure方式使用。

執行上下文（ExecutionContext）

爲了運行回調和操作，Futures需要有一個ExecutionContext。
如果你在作用域內有一個ActorSystem，它會它自己派發器用作ExecutionContext，你也可以用ExecutionContext伴生對象提供的工廠方法來將Executors和ExecutorServices進行包裹，或者甚至創建自己的實例。
通過導入ExecutionContext.Implicits.global來導入默認的全局執行上下文。你可以把該執行上下文看做是一個線程池，ExecutionContext是在某個線程池執行任務的抽象。
如果在代碼中沒有導入該執行上下文，代碼將無法編譯。

阻塞方式

第一個例子展示如何創建一個future，然後通過阻塞方式等待其計算結果。雖然阻塞方式不是一個很好的用法，但是可以說明問題。
這個例子中，通過在未來某個時間計算1+1，當計算結果後再返回。

import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

object FutureBlockDemo extends App{
  implicit val baseTime = System.currentTimeMillis

  // create a Future
  val f = Future {
    Thread.sleep(500)
    1+1
  }
  // this is blocking(blocking is bad)
  val result = Await.result(f, 1 second)
  // 如果Future沒有在Await規定的時間裏返回,
  // 將拋出java.util.concurrent.TimeoutException
  println(result)
  Thread.sleep(1000)
}

代碼解釋：

1. 在上面的代碼中，被傳遞給Future的代碼塊會被缺省的Dispatcher所執行，代碼塊的返回結果會被用來完成Future。 與從Actor返回的Future不同，這個Future擁有正確的類型, 我們還避免了管理Actor的開銷。
2. Await.result方法將阻塞1秒時間來等待Future結果返回，如果Future在規定時間內沒有返回，將拋出java.util.concurrent.TimeoutException異常。
3. 通過導入scala.concurrent.duration._，可以用一種方便的方式來聲明時間間隔，如100 nanos，500 millis，5 seconds、1 minute、1 hour，3 days。還可以通過Duration(100, MILLISECONDS)，Duration(200, "millis")來創建時間間隔。

非阻塞方式（回調方式）

有時你只需要監聽Future的完成事件，對其進行響應，不是創建新的Future，而僅僅是產生副作用。
通過onComplete,onSuccess,onFailure三個回調函數來異步執行Future任務，而後兩者僅僅是第一項的特例。

使用onComplete的代碼示例：

import scala.concurrent.{Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}
import scala.util.Random

object FutureNotBlock extends App{
  println("starting calculation ...")
  val f = Future {
    Thread.sleep(Random.nextInt(500))
    42
  }

  println("before onComplete")
  f.onComplete{
    case Success(value) => println(s"Got the callback, meaning = $value")
    case Failure(e) => e.printStackTrace
  }

  // do the rest of your work
  println("A ...")
  Thread.sleep(100)
  println("B ....")
  Thread.sleep(100)
  println("C ....")
  Thread.sleep(100)
  println("D ....")
  Thread.sleep(100)
  println("E ....")
  Thread.sleep(100)

  Thread.sleep(2000)
}

使用onSuccess、onFailure的代碼示例：

import scala.concurrent.{Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}
import scala.util.Random

object Test12_FutureOnSuccessAndFailure extends App{
  val f = Future {
    Thread.sleep(Random.nextInt(500))
    if (Random.nextInt(500) > 250) throw new Exception("Tikes!") else 42
  }

  f onSuccess {
    case result => println(s"Success: $result")
  }

  f onFailure {
    case t => println(s"Exception: ${t.getMessage}")
  }

  // do the rest of your work
  println("A ...")
  Thread.sleep(100)
  println("B ....")
  Thread.sleep(100)
  println("C ....")
  Thread.sleep(100)
  println("D ....")
  Thread.sleep(100)
  println("E ....")
  Thread.sleep(100)

  Thread.sleep(1000)
}

代碼解釋：
上面兩段例子中，Future結構中隨機延遲一段時間，然後返回結果或者拋出異常。
然後在回調函數中進行相關處理。

創建返回Future[T]的方法

先看一下示例：

import scala.concurrent.{Await, Future, future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object ReturnFuture extends App{
  implicit val baseTime = System.currentTimeMillis

  // `future` method is another way to create a future
  // It starts the computation asynchronously and retures a Future[Int] that
  // will hold the result of the computation.
  def longRunningComputation(i: Int): Future[Int] = future {
    Thread.sleep(100)
    i + 1
  }

  // this does not block
  longRunningComputation(11).onComplete {
    case Success(result) => println(s"result = $result")
    case Failure(e) => e.printStackTrace
  }

  // keep the jvm from shutting down
  Thread.sleep(1000)
}

代碼解釋：
上面代碼中的longRunningComputation返回一個Future[Int]，然後進行相關的異步操作。
其中future方法是創建一個future的另一種方法。它將啓動一個異步計算並且返回包含計算結果的Future[T]。

Future用於Actor

通常有兩種方法來從一個Actor獲取迴應: 第一種是發送一個消息actor ! msg，這種方法只在發送者是一個Actor時有效；第二種是通過一個Future。
使用Actor的?方法來發送消息會返回一個Future。 要等待並獲取結果的最簡單方法是:

import scala.concurrent.Await
import akka.pattern.ask
import scala.concurrent.duration._
import akka.util.Timeout

implicit val timeout = Timeout(5 seconds)
val future = actor ? msg
val result = Await.result(future, timeout.duration).asInstanceOf[String]

下面是使用?發送消息給actor，並等待迴應的代碼示例：

import akka.actor._
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.{Await, Future}
import scala.language.postfixOps
import scala.concurrent.duration._

case object AskNameMessage

class TestActor extends Actor {
  def receive = {
    case AskNameMessage => // respond to the 'ask' request
      sender ! "Fred"
    case _ => println("that was unexpected")
  }
}
object AskDemo extends App{
  //create the system and actor
  val system = ActorSystem("AskDemoSystem")
  val myActor = system.actorOf(Props[TestActor], name="myActor")

  // (1) this is one way to "ask" another actor for information
  implicit val timeout = Timeout(5 seconds)
  val future = myActor ? AskNameMessage
  val result = Await.result(future, timeout.duration).asInstanceOf[String]
  println(result)

  // (2) a slightly different way to ask another actor for information
  val future2: Future[String] = ask(myActor, AskNameMessage).mapTo[String]
  val result2 = Await.result(future2, 1 second)
  println(result2)

  system.shutdown
}

代碼解釋：

1. Await.result(future, timeout.duration).asInstanceOf[String]會導致當前線程被阻塞，並等待actor通過它的應答來完成Future。但是阻塞會導致性能問題，所以是不推薦的。致阻塞的操作位於Await.result和Await.ready中，這樣就方便定位阻塞的位置。
2. 還要注意actor返回的Future的類型是Future[Any]，這是因爲actor是動態的。 這也是爲什麼上例中註釋(1)使用了asInstanceOf。
3. 在使用非阻塞方式時，最好使用mapTo方法來將Future轉換到期望的類型。如果轉換成功，mapTo方法會返回一個包含結果的新的 Future，如果不成功，則返回ClassCastException異常。

轉載請註明作者Jason Ding及其出處
Github博客主頁(http://jasonding1354.github.io/)
GitCafe博客主頁(http://jasonding1354.gitcafe.io/)
CSDN博客(http://blog.csdn.net/jasonding1354)
簡書主頁(http://www.jianshu.com/users/2bd9b48f6ea8/latest_articles)
Google搜索jasonding1354進入我的博客主頁