Scala并发编程【进阶】

 package com.dingxin.entrance

 import java.text.SimpleDateFormat
 import java.util.Date

 import scala.actors.Actor
 import scala.actors.Actor._
 /**
   * Created by zhen on 2019/1/24.
   */
 object My_Actor_Receive extends Actor{
   def act(){
     while(true){
       receive{
         case str : String => print(str + " ") // 模式匹配
         case dat : Date => println(new SimpleDateFormat("yyyy").format(dat))
         case _ => println("My heart will go on !")
       }
     }
   }
 }
 object Actor_Receive {
   def main(args: Array[String]) {
     val getMessage = actor{
       while(true){
         receive{
           case str : String => print(str) // 模式匹配
           case dat : Date => println(new SimpleDateFormat("yyyy").format(dat))
           case _ => My_Actor_Receive ! null // 消息转发
         }
       }
     }
     val sendMessage = actor{
       while(true){
         receive{
           case str : String => getMessage ! str + " " // 消息转发
           case dat : Date => getMessage ! dat
           case _ => getMessage ! null
         }
       }
     }
     sendMessage ! "Scala"
     sendMessage ! new Date()
     sendMessage ! 2020

     // 这种方式必须执行start开启，且都是并行执行，不确定先后顺序
     My_Actor_Receive.start()
     My_Actor_Receive ! "Spark"
   }
 }

结果1：

　　

结果2：

　　

信息交互

 package big.data.analyse.scala

 import scala.actors.Actor
 import scala.actors.Actor._
 /**
   * 消息发送与接收,可用于流计算测试的输入
   * Created by zhen on 2018/4/15.
   */
 object ActorTest {
   def main(args: Array[String]) {
     val actor = new HelloActor
     actor.start//启动actor消息机制
     var counter = 0
     while(counter<10){
       actor ! "Step " + counter //发送消息
       counter += 1
       Thread.sleep(2000)
       self.receive{case msg => println("返回结果："+msg)} // 获取子线程的消息
     }
   }
 }
 class HelloActor extends Actor{
   def act(): Unit ={
     while(true){
       receive{
         case content : String => println("Message : " + content)
           sender ! content.split(" ")(1) // 向主线程发送消息
       }
     }
   }
 }

结果3：

　　

loop+react

 package big.data.analyse.scala.actor

 import java.net.{UnknownHostException, InetAddress}
 import scala.actors.Actor
 import scala.actors.Actor._

 /**
   * Created by zhen on 2019/6/19.
   */
 object NameResolver extends Actor{
   def act(){
     loop {
       react {
         case Net (name, actor) => actor ! getIp(name)
         case msg => println("Unhandled message : " + msg)
       }
     }
   }
   def getIp(name : String) : Option[InetAddress] = {
     try{
       println(name)
       Some(InetAddress.getByName(name))
     } catch {
       case _ : UnknownHostException => None
     }
   }
 }

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

 object Actor_More_Effective {
   def main(args: Array[String]) {
     NameResolver.start
     NameResolver ! Net("www.baidu.com", self)
     NameResolver ! "www.xiaomi.com"

     for(i <- 1 until 10){
       NameResolver ! "小米" + i
     }
     println(self.receiveWithin(1000){case x => x})
   }
 }

结果4：

　　

Actor详解

　　1.Actor是一个通信模型，Scala提供了Actor的实现

　　2.Spark1.6之前集群节点之间通信使用的是Akka，Akka底层是Actor实现的。Spark1.6之后，节点的通信变成Netty

　　3.Actor相当于我们理解的Thread，Actor的出现主要解决的是代码锁的问题

　　4.Actor底层通信实现用到了模式匹配