ITPub博客

首页 > 应用开发 > Java > Scala并发编程

Scala并发编程

原创 Java 作者:541732025 时间:2016-03-08 15:19:24 0 删除 编辑
在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/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论

注册时间:2013-05-23

  • 博文量
    127
  • 访问量
    479705