Scala併發程式設計

541732025發表於2016-03-08
程式設計
在java中，基於共享資料、加鎖的執行緒模型，使得java併發程式設計越來越複雜，而在Scala中採用actor模型，不共享資料，依賴訊息傳遞的併發程式設計模型

點選(此處)摺疊或開啟

  1. object Actor_Message extends Actor {
  2.   def act() {
  3.     while(true){
  4.         receive { //收件箱
  5.           case msg => println("Message content Actor from inbox: " + msg)
  6.         }
  7.       }
  8.   }
  9. }
  10. object Actor_Messages {

  12.   def main(args: Array[String]) {
  13.     val actor_Message = actor{ //建立匿名actor，預設啟動
  14.       while(true){
  15.         receive { //作為偏函式，有apply方法和isDefinedAt方法，apply進行模式匹配。isDefinedAt判斷訊息能否被case處理，若是則返回true。
  16.         //正常情況下，偏函式會先呼叫isDefinedAt驗證（true還是false），確認apply呼叫時安全的，否則apply模式匹配時會異常
  17.         //而actor做了透明處理，即使沒有匹配的case，不會異常，只會忽略。receive會先呼叫isDefinedAt，如果返回true，才將訊息傳遞給偏函式的apply方法；
  18.         //最後apply方法處理訊息。如果沒有匹配成功，actor則會處於阻塞狀態。
  19.           case msg => println("Message content from inbox: " + msg)
  20.         }
  21.       }
  22.     }
  23.     val double_Message = actor{
  24.         while(true){
  25.             receive {
  26.             case msg : Double => println("Double Number from inbox: " + msg)
  27. //         case _ => println("Something Unkown" )
  28.             }
  29.         }
  30.     }
  31.     Actor_Message.start
  32.     Actor_Message ! "Hadoop" //actor傳送訊息
  33.     actor_Message ! "Spark"
  34.     double_Message ! Math.PI
  35.     double_Message ! "Hadoop"
  36.     
  37.   }

  39. }

原生執行緒、case class訊息傳遞下的偏函式解析

點選(此處)摺疊或開啟

  1. case class Person(name: String, age: Int)

  3. class HelloActor extends Actor{
  4.   def act(){
  5.     while(true){
  6.         receive { //把收到的訊息傳給偏函式
  7.           case Person(name, age) => { //線性執行，不存在資源爭用的情況
  8.             println("Name: " + name + " : " + "Age: " + age)
  9.             sender ! "Echo!!!" //給傳送訊息的actor回覆訊息。將計算結果以訊息的方式傳遞給其他資料消費者，不要有全域性共享的資料
  10.                       }
  11.           case _ => println("Something else...") //其他訊息的處理，避免郵箱被佔滿
  12.         }
  13.       }
  14.   }
  15. }
  16. object Actor_With_CaseClass {

  18.   def main(args: Array[String]) {
  19.     val hiActor = new HelloActor
  20.     hiActor.start
  21.     hiActor ! Person("Spark", 6) //傳送者為main所在的actor
  22.     
  23.     self.receive{case msg => println(msg)} //self為當前main方法所在actor的引用，這裡接收其他執行緒傳送給主執行緒的訊息
  24. // self.receiveWithin(1000){case msg => println(msg)}
  25.   }
  26. }

react、loop，基於執行緒重用，讓效能有所提升

點選(此處)摺疊或開啟

  1. object NameResolver extends Actor{
  2.  
  3.   def act(){
  4.     react { //react處理完訊息後沒有返回
  5.       case Net (name, actor) =>
  6.         actor ! getIp(name) //這裡actor就是main傳過來的，即sender
  7.         act //actor執行緒重複執行，如果不加act方法，執行緒執行完任務後將終止
  8.       case "EXIT" => println("Name resolver exiting.")
  9.       case msg =>
  10.         println("Unhandled message : " + msg)
  11.           act
  12.     }

  14.     //這兩種方式結果一樣，寫法不同而已
  15.     loop {
  16.       react {
  17.      case Net (name, actor) =>
  18.          actor ! getIp(name)
  19.          
  20.      case msg =>
  21.          println("Unhandled message : " + msg)
  22.     }
  23.     }
  24.  
  25.   }
  26.   def getIp(name : String) : Option[InetAddress] = {
  27.     try{
  28.       println(InetAddress.getByName(name))
  29.       Some(InetAddress.getByName(name))
  30.     } catch {
  31.       case _ : UnknownHostException => None
  32.     }
  33.   }
  34. }

  36. case class Net(name : String, actor: Actor)

  38. object Actor_More_Effective {
  39.   def main(args: Array[String]) {
  40.     NameResolver.start
  41.     NameResolver ! Net("", self) //main所在actor發訊息
  42.     
  43.     println(self.receiveWithin(1000){case x => x}) //main所在actor收訊息
  44.   }
  45. }

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/28912557/viewspace-2051342/，如需轉載，請註明出處，否則將追究法律責任。

相關文章