Akka 是一個用 Scala 編寫的庫，用於簡化編寫容錯的、高可伸縮性的 Java 和 Scala 的 Actor 模型應用。 
Actor模型並非什麼新鮮事物，它由Carl Hewitt於上世紀70年代早期提出，目的是為了解決分散式程式設計中一系列的程式設計問題。其特點如下：

• 系統中的所有事物都可以扮演一個Actor
• Actor之間完全獨立
• 在收到訊息時Actor所採取的所有動作都是並行的，在一個方法中的動作沒有明確的順序
• Actor由標識和當前行為描述
• Actor可能被分成原始（primitive）和非原始（non primitive）類別
• 非原始Actor有
• • 由一個郵件地址表示的標識
• • 當前行為由一組知識（acquaintances）（例項變數或本地狀態）和定義Actor在收到訊息時將採取的動作組成
• 訊息傳遞是非阻塞和非同步的，其機制是郵件佇列（mail-queue）
• 所有訊息傳送都是並行的

使用Actor

Actor是Scala的併發模型。在2.10之後的版本中，使用http://akka.io/作為其推薦Actor實現。 
Actor是類似執行緒的實體，有一個郵箱。 
可以通過system.actorOf來建立,receive獲取郵箱訊息，！向郵箱傳送訊息。 這個例子是一個EchoServer，接受資訊並列印。

1. import akka.actor.{Actor,ActorSystem,Props}
2. val system =ActorSystem()
3. classEchoServerextendsActor
   {
4. def receive ={
5. case msg:String=> println("echo "+ msg)
6. }
7. }
8. val echoServer = system.actorOf(Props[EchoServer])
9. echoServer !"hi"
10. system.shutdown

Actor更簡化的用法

可以通過更簡化的辦法宣告Actor。 匯入akka.actor.ActorDSL中的actor函式。 這個函式可以接受一個Actor的構造器Act，啟動並返回Actor。

1. import akka.actor.ActorDSL._
2. import akka.actor.ActorSystem
3. implicit val system =ActorSystem()
4. val echoServer = actor(newAct{
5. become {
6. case msg => println("echo "+ msg)
7. }
8. })
9. echoServer !"hi"
10. system.shutdown

Actor原理

Actor比執行緒輕量。在Scala中可以建立數以百萬級的Actor。奧祕在於Actor可以複用執行緒。 
Actor和執行緒是不同的抽象，他們的對應關係是由Dispatcher決定的。 
這個例子建立4個Actor，每次呼叫的時候列印自身執行緒。 可以發現Actor和執行緒之間沒有一對一的對應關係。 一個Actor可以使用多個執行緒，一個執行緒也會被多個Actor複用。

1. import akka.actor.{Actor,Props,ActorSystem}
2. import akka.testkit.CallingThreadDispatcher
3. implicit val system =ActorSystem()
4. classEchoServer(name:String)extendsActor{
5. def receive ={
6. case msg => println("server"+ name +" echo "+ msg +
7. " by "+Thread.currentThread().getName())
8. }
9. }
10. val echoServers =(1 to 10).map(x =>
11. system.actorOf(Props(newEchoServer(x.toString))
12. .withDispatcher(CallingThreadDispatcher.Id)))
13. (1 to 10).foreach(msg =>
14. echoServers(scala.util.Random.nextInt(10))! msg.toString)
15. system.shutdown

同步返回

Actor非常適合於較耗時的操作。比如獲取網路資源。 
這個例子通過呼叫ask函式來獲取一個Future。 在Actor內部通過 sender ! 傳遞結果。 Future像Option一樣有很多高階方法，可以使用foreach檢視結果。

1. import akka.actor.ActorDSL._
2. import akka.pattern.ask
3. implicit val ec = scala.concurrent.ExecutionContext.Implicits.global
4. implicit val system = akka.actor.ActorSystem()
5. val versionUrl ="https://raw.github.com/scala/scala/master/starr.number"
6. val fromURL = actor(newAct{
7. become {
8. case url:String=> sender ! scala.io.Source.fromURL(url)
9. .getLines().mkString("\n")
10. }
11. })
12. val version = fromURL.ask(versionUrl)(akka.util.Timeout(5*1000))
13. version.foreach(println _)
14. system.shutdown

非同步返回

非同步操作可以最大發揮效能。Scala的Futrue很強大，可以非同步返回。 可以實現Futrue的onComplete方法。當Futrue結束的時候就會回撥。 在呼叫ask的時候，可以設定超時。

1. import akka.actor.ActorDSL._
2. import akka.pattern.ask
3. implicit val ec = scala.concurrent.ExecutionContext.Implicits.global
4. implicit val system = akka.actor.ActorSystem()
5. val versionUrl ="https://raw.github.com/scala/scala/master/starr.number"
6. val fromURL = actor(newAct{
7. become {
8. case url:String=> sender ! scala.io.Source.fromURL(url)
9. .getLines().mkString("\n")
10. }
11. })
12. val version = fromURL.ask(versionUrl)(akka.util.Timeout(5*1000))
13. version onComplete {
14. case msg => println(msg); system.shutdown
15. }

併發集合

這個例子是訪問若干URL，並記錄時間。 如果能併發訪問，就可以大幅提高效能。 嘗試將urls.map修改為urls.par.map。這樣每個map中的函式都可以併發執行。 當函式式和併發結合，就會這樣讓人興奮。

1. import scala.io.Codec
2. import java.nio.charset.CodingErrorAction
3. implicit val codec =Codec("UTF-8")
4. codec.onMalformedInput(CodingErrorAction.REPLACE)
5. codec.onUnmappableCharacter(CodingErrorAction.REPLACE)
6. val urls ="http://scala-lang.org"::"https://github.com/yankay/scala-tour"::Nil
7. def fromURL(url:String)= scala.io.Source.fromURL(url).getLines().mkString("\n")
8. val s =System.currentTimeMillis()
9. time(urls.map(fromURL(_)))
10. println("time: "+(System.currentTimeMillis - s)+"ms")