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

JasonDing1354發表於2016-01-21

引言

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

Future直接使用

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

阻塞方式（Blocking）：該方式下，父actor或主程式停止執行知道所有future完成各自任務。通過scala.concurrent.Await使用。

非阻塞方式（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)
}

程式碼解釋：

在上面的程式碼中，被傳遞給Future的程式碼塊會被預設的Dispatcher所執行，程式碼塊的返回結果會被用來完成Future。與從Actor返回的Future不同，這個Future擁有正確的型別, 我們還避免了管理Actor的開銷。

Await.result方法將阻塞1秒時間來等待Future結果返回，如果Future在規定時間內沒有返回，將丟擲java.util.concurrent.TimeoutException異常。

通過匯入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
}