Scala并发编程

在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 {

  11.   def main(args: Array[String]) {
  12.     val actor_Message = actor{ //创建匿名actor,默认启动
  13.       while(true){
  14.         receive { //作为偏函数,有apply方法和isDefinedAt方法,apply进行模式匹配。isDefinedAt判断消息能否被case处理,若是则返回true。
  15.         //正常情况下,偏函数会先调用isDefinedAt验证(true还是false),确认apply调用时安全的,否则apply模式匹配时会异常
  16.         //而actor做了透明处理,即使没有匹配的case,不会异常,只会忽略。receive会先调用isDefinedAt,如果返回true,才将消息传递给偏函数的apply方法;
  17.         //最后apply方法处理消息。如果没有匹配成功,actor则会处于阻塞状态。
  18.           case msg => println("Message content from inbox: " + msg)
  19.         }
  20.       }
  21.     }
  22.     val double_Message = actor{
  23.         while(true){
  24.             receive {
  25.             case msg : Double => println("Double Number from inbox: " + msg)
  26. //         case _ => println("Something Unkown" )
  27.             }
  28.         }
  29.     }
  30.     Actor_Message.start
  31.     Actor_Message ! "Hadoop" //actor发送消息
  32.     actor_Message ! "Spark"
  33.     double_Message ! Math.PI
  34.     double_Message ! "Hadoop"
  35.     
  36.   }

  37. }

原生线程、case class消息传递下的偏函数解析

点击(此处)折叠或打开

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

  2. class HelloActor extends Actor{
  3.   def act(){
  4.     while(true){
  5.         receive { //把收到的消息传给偏函数
  6.           case Person(name, age) => { //线性执行,不存在资源争用的情况
  7.             println("Name: " + name + " : " + "Age: " + age)
  8.             sender ! "Echo!!!" //给发送消息的actor回复消息。将计算结果以消息的方式传递给其他数据消费者不要有全局共享的数据
  9.                       }
  10.           case _ => println("Something else...") //其他消息的处理,避免邮箱被占满
  11.         }
  12.       }
  13.   }
  14. }
  15. object Actor_With_CaseClass {

  16.   def main(args: Array[String]) {
  17.     val hiActor = new HelloActor
  18.     hiActor.start
  19.     hiActor ! Person("Spark", 6) //发送者为main所在的actor
  20.     
  21.     self.receive{case msg => println(msg)} //self为当前main方法所在actor的引用,这里接收其他线程发送给主线程的消息
  22. // self.receiveWithin(1000){case msg => println(msg)}
  23.   }
  24. }

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.     }

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

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

  35. object Actor_More_Effective {
  36.   def main(args: Array[String]) {
  37.     NameResolver.start
  38.     NameResolver ! Net("www.baidu.com", self) //main所在actor发消息
  39.     
  40.     println(self.receiveWithin(1000){case x => x}) //main所在actor收消息
  41.   }
  42. }

来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/28912557/viewspace-2051342/,如需转载,请注明出处,否则将追究法律责任。

转载于:http://blog.itpub.net/28912557/viewspace-2051342/

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值