Scala基础(二)--Actor编程模型

Scala中的Actor

Scala中的Actor能够实现并行编程的强大功能，它是基于事件模型的并发机制，Scala是运用消息（message）的发送、接收来实现多线程的。使用Scala能够更容易地实现多线程应用的开发。

• 传统Java并发编程与Scala Actor编程的比较

Java内置线程模型	Scala Actor模型
“共享数据-锁”模型(share data and lock)	share nothing
每个Object有一个monitor,监视多线程对共享数据的访问	不共享数据，actor之间通过message通讯
加锁的代码用synchronized标识
死锁问题
每个线程内部是顺序执行的	每个actor内部是顺序执行的

对于Java，我们都知道它的多线程实现需要对共享资源（变量、对象等）使用synchronized 关键字进行代码块同步、对象锁互斥等等。而且，常常一大块的try…catch语句块中加上wait方法、notify方法、notifyAll方法是让人很头疼的。原因就在于Java中多数使用的是可变状态的对象资源，对这些资源进行共享来实现多线程编程的话，控制好资源竞争与防止对象状态被意外修改是非常重要的，而对象状态的不变性也是较难以保证的。 而在Scala中，我们可以通过复制不可变状态的资源（即对象，Scala中一切都是对象，连函数、方法也是）的一个副本，再基于Actor的消息发送、接收机制进行并行编程

• Actor方法的执行顺序
  • 1.首先调用start()方法启动Actor
  • 2.调用start()方法后其act()方法会被执行
  • 3.向Actor发送消息
• 发送消息的方式
  • ! 发送异步消息，没有返回值。
  • !? 发送同步消息，等待返回值。
  • !! 发送异步消息，返回值是 Future[Any]
• 第一个例子

 import scala.actors.Actor

object MyActor1 extends Actor{
  //重写act方法
  override def act(): Unit = {
      for(i <- 1 to 10 ){
         println("actor-1 : " + i )
        Thread.sleep(2*1000)
      }
  }
}
object MyActor2 extends Actor{
  override def act(): Unit = {
      for(i <- 1 to 10 ){
          println("actor-2 : " + i )
          Thread.sleep(2 * 1000 )
      }
  }
}
object ActorTest extends App{
  //启动Actor
  MyActor1.start()
  MyActor2.start()
}
//执行效果如下:
actor-1 : 1
actor-2 : 1
actor-2 : 2
actor-1 : 2
actor-1 : 3
actor-2 : 3
actor-2 : 4
actor-1 : 4
actor-2 : 5
actor-1 : 5
actor-2 : 6
actor-1 : 6
actor-1 : 7
actor-2 : 7
actor-1 : 8
actor-2 : 8
actor-2 : 9
actor-1 : 9
actor-2 : 10
actor-1 : 10

说明：上面分别调用了两个单例对象的start()方法，他们的act()方法会被执行，相同与在java中开启了两个线程，线程的run()方法会被执行
注意：这两个Actor是并行执行的，act()方法中的for循环执行完成后actor程序就退出了

• 第二个例子（可以不断地接收消息）

 class MyActor extends Actor{
  override def act(): Unit = {
    while(true){
      receive{
        case "start" => {
            println("Starting....")
            Thread.sleep(5*1000)
            println("Started....")
        }
        case "stop" => {
           println("stopping....")
           Thread.sleep(5*1000)
            println("stopped.....")
        }
      }
    }
  }
}
object MyActor{
  def main(args: Array[String]): Unit = {
    val actor = new MyActor
    actor.start()
    actor ! "start"
    actor ! "stop"
    Thread.sleep(5*1000)
    actor ! "start"

    println("消息发送完成！")
  }
}
// 运行结果如下：
Starting....
消息发送完成！
Started....
stopping....
stopped.....
Starting....
Started....

说明：在act()方法中加入了while (true) 循环，就可以不停的接收消息
注意：发送start消息和stop的消息是异步的，但是Actor接收到消息执行的过程是同步的按顺序执行

*第三个例子（react方式会复用线程，比receive更高效）

 import scala.actors.Actor

class YourActor extends Actor{
  override def act(): Unit = {
     loop{
       react{
         case "start" => {
            println("starting....")
           Thread.sleep(5*1000)
           println("started")
         }
         case "stop" => {
            println("stopping....")
           Thread.sleep(8 * 1000)
           println("stopped....")
         }
       }
     }
  }
}
object YourActor{
  def main(args: Array[String]): Unit = {
      val actor = new YourActor
      actor.start()
      actor ! "start"
      actor ! "stop"
      println("消息发送完成！")

  }
}
//执行结果如下:
starting....
消息发送完成！
started
stopping....
stopped....

说明： react 如果要反复执行消息处理，react外层要用loop，不能用while

• 第四个例子（结合case class发送消息）

import scala.actors.Actor

class AppleActor extends Actor{
  override def act(): Unit = {
    while(true){
      receive{
        case "start" => println("starting....")
        case SyncMsg(id,msg) => {
            println(id + ",sync " + msg )
            Thread.sleep( 5 * 1000 )
          sender ! ReplyMsg(id,"finished")
        }
        case AsyncMSg(id,msg) => {
          println(id + ",async " + msg )
          Thread.sleep(5*1000)
        }
      }
    }
  }
}
object AppleActor{
  def main(args: Array[String]): Unit = {
    val a = new AppleActor
    a.start()
    //异步消息
    a ! AsyncMSg(1,"hello actor")
    println("异步消息发送完成")
    // 同步消息
    val content = a.!?(SyncMsg(2,"hello actor"))
    Thread.sleep(6*1000)
    println(content)
    val reply = a !! SyncMsg(3,"hello actor")
    println(reply.isSet)
    val c = reply.apply()
    println(reply.isSet)
    println(c)
  }
}
case class SyncMsg(id:Int,msg:String)
case class AsyncMSg(id:Int,msg:String)
case class ReplyMsg(id:Int,msg:String)

// 执行结果如下：
异步消息发送完成
1,async hello actor
2,sync hello actor
ReplyMsg(2,finished)
false
3,sync hello actor
true
ReplyMsg(3,finished)

• 单机版的wordcount Scala实现

import scala.actors.{Actor, Future}
import scala.collection.mutable.{HashSet, ListBuffer}
import scala.io.Source

class Task extends Actor{
  override def act(): Unit = {
    loop{
      react{
        case SubmitTask(filename) => {
        val result =  Source.fromFile(filename).getLines().flatMap(_.split(" ")).map((_,1)).toList.groupBy(_._1).mapValues(_.size)
          sender ! ResultTask(result)
        }
        case StopTask => {
            exit()
        }
      }
    }
  }
}
case class SubmitTask(filename:String)
case class ResultTask(result:Map[String,Int])
case object StopTask
object ActorWordCount {
  def main(args: Array[String]): Unit = {
      val replySet = new  HashSet[Future[Any]]()
      val resultList = new ListBuffer[ResultTask]()
      val files = Array[String]("D://words.txt","D://words.log")
      for(f <- files ){
         val actor = new Task
         val reply = actor.start() !! SubmitTask(f)
         replySet += reply
      }
      while(replySet.size > 0 ){
        val toCompute = replySet.filter(_.isSet)
        for(r <- toCompute){
        val result =  r.apply().asInstanceOf[ResultTask]
          resultList += result
          replySet -= r
        }
        Thread.sleep(100)
      }
    //汇总的功能
    //List((hello,5),(tom,3),(hello,2),(jerry,2))
     val fr =  resultList.flatMap(_.result).groupBy(_._1).mapValues(_.foldLeft(0)(_+_._2))
     println(fr)
  }
}
//执行效果：
Map(tom -> 3, kitty -> 3, jerry -> 4, hello -> 10)