欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Scala之——Actor编程(基于Scala2.10.x)

程序员文章站 2024-02-22 21:22:22
...

转载请注明出处:https://blog.csdn.net/l1028386804/article/details/80865796

1. 什么是 Scala Actor

1.1.概念

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

1.2.传统 java 并发编程与 Scala Actor 编程的区别

Scala之——Actor编程(基于Scala2.10.x) 

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

 1.3. Actor 方法执行顺序

  • 1.首先调用 start()方法启动 Actor
  • 2.调用 start()方法后其 act()方法会被执行
  • 3.Actor 发送消息

1.4.发送消息的方式

!

发送异步消息,没有返回值。

!?

发送同步消息,等待返回值。

!!

发送异步消息,返回值是 Future[Any]。

2. Actor 实战

2.1 Actor实现多线程开发

package com.lyz.scala

import scala.actors.Actor

/**
 * Scala线程实例1
 * @author liuyazhuang
 *
 */
object MyActor1 extends Actor{
	override
	def act(){
	  for(i <- 1 to 10){
	    println("actor-1" + i)
	    Thread.sleep(2000)
	  }
	}
}

object MyActor2 extends Actor{
  override
  def act(){
    for(i <- 1 to 10){
      println("actor-2" + i)
      Thread.sleep(2000)
    }
  }
}

object ActorTest extends App{
  MyActor1.start()
  MyActor2.start()
}
说明: 上面分别调用了两个单例对象的 start()方法,他们的 act()方法会被执行,相当于在 java中开启了两个线程,线程的 run()方法会被执行
注意:这两个 Actor 是并行执行的, act()方法中的 for 循环执行完成后 actor 程序就退出了

2.2 不断接收消息

package com.lyz.scala

import scala.actors.Actor

/**
 * 不断的接收消息
 * @author liuyazhuang
 *
 */
class MyActorMessage extends Actor{
	
  override def act(): Unit = {
    while (true) {
      receive{
        case "start" => {
	        println("starting...")
	        Thread.sleep(5000)
	        println("started")
	     }
        case "stop" => {
          println("stopping...")
          Thread.sleep(5000)
          println("stopped")
        }
      }
    }
  }
}

object MyActor{
  def main(args: Array[String]) {
	  var actor = new MyActorMessage
	  actor.start();
	  actor ! "start"
	  actor ! "stop"
	  println("消息发送完成")
  }
}
说明: 在 act()方法中加入了 while (true) 循环,就可以不停的接收消息
注意:发送 start 消息和 stop 的消息是异步的,但是 Actor 接收到消息执行的过程是同步的按顺序执行

2.3 react方式

package com.lyz.scala

import scala.actors.Actor

/**
 * react 方式会复用线程,比 receive 更高效
 * @author liuyazhuang
 *
 */
class MyActorReact extends Actor{
	
  override def act() : Unit = {
	loop{
	  react{
	    case "start" => {
	      println("starting...")
	      Thread.sleep(2000)
	      println("started");
	    }
	    case "stop" => {
	      println("stopping...")
	      Thread.sleep(2000)
	      println("stopped")
	    }
	  }
	}
  }
}

object MyReact{
	def main(args: Array[String]) {
		  var react = new MyActorReact
		  react.start()
		  react ! "start"
		  react ! "stop"
		  println("消息发送完成")
	}
}

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

2.4 结合case class发送消息

package com.lyz.scala

import scala.actors.Actor

/**
 * 结合case calss发送消息
 * @author liuyazhuang
 *
 */
class AppleActor extends Actor{
	override def act():Unit= {
	  while (true) {
		  receive{
		    case "start" => println("startting...")
		    case SyncMsg(id, msg) => {
		      println(id + " sync " + msg)
		      Thread.sleep(2000)
		      sender ! ReplyMsg(3, "finished")
		    }
		    case AsyncMsg(id, msg) => {
		      println(id + " async " + msg)
		      Thread.sleep(2000)
		    }
		  }
	  }
	}
}

object AppleActor{
  def main(args: Array[String]) {
	  var a = new AppleActor
	  a.start()
	  //异步消息
	  a ! AsyncMsg(1, "hello actor")
	  println("发送异步消息完成")
	  
	  //同步消息
	  var reply = a !! SyncMsg(2, "hello actor")
	  println(reply.isSet)
	  
	  var 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)

3、案例

actor 并发编程写一个单机版的 WorldCount,将多个文件作为输入,计算完成后将多个任务汇总,得到最终的结果

package com.lyz.scala

import scala.actors.{Actor, Future}
import scala.collection.mutable
import scala.io.Source
import java.io.File
import javax.swing.text.MutableAttributeSet

/**
 * 用 actor 并发编程写一个单机版的 WorldCount,将多个文件作为输入,计算完成后将多个任
   务汇总,得到最终的结果
 * @author liuyazhuang
 *
 */
class Task extends Actor{
	override def act() : Unit = {
	  loop{
	    react{
	      case SubmitTask(fileName) => {
	        val contents = Source.fromFile(new File(fileName)).mkString
	        val arr = contents.split("\r\n")
	        val result = arr.flatMap(_.split(" ")).map((_, 1)).groupBy(_._1).mapValues(_.length)
	        sender ! ResultTask(result)
	      }
	      case StopTask => {
	        exit()
	      }
	    }
	  }
	}
}

object WordCount{
  def main(args: Array[String]) {
	  val files = Array("d:/words.txt ", "d:/words.log")
	  
	  val replySet = new mutable.HashSet[Future[Any]]
	  val resultList = new mutable.ListBuffer[ResultTask]
	  
	  for(f <- files){
	    val t = new Task
	    val reply = t.start() !! SubmitTask(f)
	    replySet += reply
	  }
	  
	  while (replySet.size > 0) {
		  val toCompute = replySet.filter(_.isSet)
		  for(r <- toCompute){
		    val result = r.apply()
		    resultList += result.asInstanceOf[ResultTask]
		    replySet.remove(r)
		  }
		  Thread.sleep(100)
	  }	
	  val finalResult = resultList.map(_.result).flatten.groupBy(_._1).mapValues(x => x.foldLeft(0)(_ + _._2))
	  println(finalResult)
  }
}

case class SubmitTask(fileName : String)
case object StopTask
case class ResultTask(result : Map[String, Int])

相关标签: Scala