文章目录
Actor介绍
scala的Actor并发编程模型可以用来开发比Java线程效率更高的并发程序。我们学习scala Actor的目的主要是为后续学习Akka做准备。
Java并发编程的问题
在Java并发编程中,每个对象都有一个逻辑监视器(monitor),可以用来控制对象的多线程访问。我们添加sychronized关键字来标记,需要进行同步加锁访问。这样,通过加锁的机制来确保同一时间只有一个线程访问共享数据。但这种方式存在资源争夺、以及死锁问题,程序越大问题越麻烦。
线程死锁
Actor并发编程模型
Actor并发编程模型,是scala提供给程序员的一种与Java并发编程完全不一样的并发编程模型,是一种基于事件模型的并发机制。Actor并发编程模型是一种不共享数据,依赖消息传递的一种并发编程模式,有效避免资源争夺、死锁等情况。
Java并发编程对比Actor并发编程
Java内置线程模型 | scala Actor模型 |
---|---|
"共享数据-锁"模型 (share data and lock) | share nothing |
每个object有一个monitor,监视线程对共享数据的访问 | 不共享数据,Actor之间通过Message通讯 |
加锁代码使用synchronized标识 | |
死锁问题 | |
每个线程内部是顺序执行的 | 每个Actor内部是顺序执行的 |
[!NOTE]
scala在2.11.x版本中加入了Akka并发编程框架,老版本已经废弃。Actor的编程模型和Akka很像,我们这里学习Actor的目的是为学习Akka做准备。
创建Actor
创建Actor的方式和Java中创建线程很类似,也是通过继承来创建。
使用方式
- 定义class或object继承Actor特质
- 重写act方法
- 调用Actor的start方法执行Actor
[!NOTE]
类似于Java线程,这里的每个Actor是并行执行的
示例
示例说明
创建两个Actor,一个Actor打印1-10,另一个Actor打印11-20
- 使用class继承Actor创建(如果需要在程序中创建多个相同的Actor)
- 使用object继承Actor创建(如果在程序中只创建一个Actor)
参考代码
使用class继承Actor创建
object _05ActorDemo {
class Actor1 extends Actor {
override def act(): Unit = (1 to 10).foreach(println(_))
}
class Actor2 extends Actor {
override def act(): Unit = (11 to 20).foreach(println(_))
}
def main(args: Array[String]): Unit = {
new Actor1().start()
new Actor2().start()
}
}
使用object继承Actor创建
object Actor1 extends Actor {
override def act(): Unit =
for(i <- 1 to 10) {
println(i)
}
}
object Actor2 extends Actor {
override def act(): Unit =
for(i <- 11 to 20) {
println(i)
}
}
def main(args: Array[String]): Unit = {
Actor1.start()
Actor2.start()
}
Actor程序运行流程
- 调用start()方法启动Actor
- 自动执行act()方法
- 向Actor发送消息
- act方法执行完成后,程序会调用**exit()**方法
发送消息/接收消息
我们之前介绍Actor的时候,说过Actor是基于事件(消息)的并发编程模型,那么Actor是如何发送消息和接收消息的呢?
使用方式
发送消息
我们可以使用三种方式来发送消息:
! | 发送异步消息,没有返回值 |
---|---|
!? | 发送同步消息,等待返回值 |
!! | 发送异步消息,返回值是Future[Any] |
例如:
要给actor1发送一个异步字符串消息,使用以下代码:
actor1 ! "你好!"
接收消息
Actor中使用receive方法来接收消息,需要给receive方法传入一个偏函数
{
case 变量名1:消息类型1 => 业务处理1,
case 变量名2:消息类型2 => 业务处理2,
...
}
[!NOTE]
receive方法只接收一次消息,接收完后继续执行act方法
示例
示例说明
- 创建两个Actor(ActorSender、ActorReceiver)
- ActorSender发送一个异步字符串消息给ActorReceiver
- ActorReceive接收到该消息后,打印出来
参考代码
object ActorSender extends Actor {
override def act(): Unit = {
// 发送消息
while(true) {
ActorReceiver ! "hello!"
TimeUnit.SECONDS.sleep(3)
}
}
}
object ActorReceiver extends Actor {
override def act(): Unit = {
// 持续接收消息
while(true) {
receive {
case msg:String => println("接收到消息:" + msg)
}
}
}
}
def main(args: Array[String]): Unit = {
ActorReceiver.start()
ActorSender.start()
}
持续接收消息
通过上一个案例,ActorReceiver调用receive来接收消息,但接收一次后,Actor就退出了。
object ActorSender extends Actor {
override def act(): Unit = {
// 发送字符串消息给Actor2
val msg = "你好,ActorSender"
println(s"ActorSender: 发送消息$msg")
ActorReceiver ! msg
// 再次发送一条消息,ActorReceiver无法接收到
ActorReceiver ! "你叫什么名字?"
}
}
object ActorReceiver extends Actor {
override def act(): Unit =
receive {
case msg: String => println(s"接收Actor: 接收到$msg")
}
}
object ActorMsgDemo {
def main(args: Array[String]): Unit = {
ActorSender.start()
ActorReceiver.start()
}
}
上述代码,ActorReceiver无法接收到ActorSender发送的第二条消息。
我们希望ActorReceiver能够一直接收消息,怎么实现呢?
——我们只需要使用一个while(true)循环,不停地调用receive来接收消息就可以啦。
示例
示例说明
- 在上一个案例的基础上,让ActorReceiver能够一直接收消息
object ActorSender extends Actor {
override def act(): Unit = {
// 发送消息
while(true) {
ActorReceiver ! "hello!"
TimeUnit.SECONDS.sleep(3)
}
}
}
object ActorReceiver extends Actor {
override def act(): Unit = {
// 持续接收消息
while(true) {
receive {
case msg:String => println("接收到消息:" + msg)
}
}
}
}
def main(args: Array[String]): Unit = {
ActorReceiver.start()
ActorSender.start()
}
使用loop和react优化接收消息
上述代码,使用while循环来不断接收消息。
- 如果当前Actor没有接收到消息,线程就会处于阻塞状态
- 如果有很多的Actor,就有可能会导致很多线程都是处于阻塞状态
- 每次有新的消息来时,重新创建线程来处理
- 频繁的线程创建、销毁和切换,会影响运行效率
在scala中,可以使用loop + react来复用线程。比while + receive更高效
示例
示例说明
使用loop + react重写上述案例
参考代码
// 持续接收消息
loop {
react {
case msg:String => println("接收到消息:" + msg)
}
}
发送和接收自定义消息
我们前面发送的消息是字符串类型,Actor中也支持发送自定义消息,常见的如:使用样例类封装消息,然后进行发送处理。
示例一
示例说明
- 创建一个MsgActor,并向它发送一个同步消息,该消息包含两个字段(id、message)
- MsgActor回复一个消息,该消息包含两个字段(message、name)
- 打印回复消息
[!TIP]
- 使用
!?
来发送同步消息- 在Actor的act方法中,可以使用sender获取发送者的Actor引用
参考代码
case class Message(id:Int, msg:String)
case class ReplyMessage(msg:String, name:String)
object MsgActor extends Actor {
override def act(): Unit = {
loop {
react {
case Message(id, msg) => {
println(s"接收到消息:${id}/${msg}")
sender ! ReplyMessage("不太好", "Tom")
}
}
}
}
}
def main(args: Array[String]): Unit = {
MsgActor.start()
val replyMessage: Any = MsgActor !? Message(1, "你好")
println("回复消息:" + replyMessage.asInstanceOf[ReplyMessage])
}
示例二
示例说明
- 创建一个MsgActor,并向它发送一个异步无返回消息,该消息包含两个字段(message, company)
[!TIP]
使用
!
发送异步无返回消息
参考代码
case class Mesasge(message:String, company:String)
object MsgActor extends Actor {
override def act(): Unit = {
loop {
react {
case Mesasge(message, company) =>
println(s"MsgActor接收到消息:${message}/${company}")
}
}
}
}
def main(args: Array[String]): Unit = {
MsgActor.start()
MsgActor ! Mesasge("中国联通", "大爷,快交话费!")
}
示例三
示例说明
- 创建一个MsgActor,并向它发送一个异步有返回消息,该消息包含两个字段(id、message)
- MsgActor回复一个消息,该消息包含两个字段(message、name)
- 打印回复消息
[!TIP]
- 使用
!!
发送异步有返回消息- 发送后,返回类型为Future[Any]的对象
- Future表示异步返回数据的封装,虽获取到Future的返回值,但不一定有值,可能在将来某一时刻才会返回消息
- Future的isSet()可检查是否已经收到返回消息,apply()方法可获取返回数据
参考代码
case class Message(id:Int, message:String)
case class ReplyMessage(message:String, name:String)
object MsgActor extends Actor {
override def act(): Unit = {
loop {
react {
case Message(id, message) =>
println(s"MsgActor接收到消息:${id}/${message}")
sender ! ReplyMessage("收到消息!", "JIm")
}
}
}
}
def main(args: Array[String]): Unit = {
MsgActor.start()
val future: Future[Any] = MsgActor !! Message(1, "你好!")
while(!future.isSet) {}
val replyMessage = future.apply().asInstanceOf[ReplyMessage]
println(replyMessage)
}
WordCount案例
接下来,我们要使用Actor并发编程模型实现多文件的单词统计。
案例介绍
给定几个文本文件(文本文件都是以空格分隔的),使用Actor并发编程来统计单词的数量
思路分析
实现思路
- MainActor获取要进行单词统计的文件
- 根据文件数量创建对应的WordCountActor
- 将文件名封装为消息发送给WordCountActor
- WordCountActor接收消息,并统计单个文件的单词计数
- 将单词计数结果发送给MainActor
- MainActor等待所有的WordCountActor都已经成功返回消息,然后进行结果合并
步骤1 | 获取文件列表
实现思路
在main方法中读取指定目录(${project_root_dir}/data/)下的所有文件,并打印所有的文件名
实现步骤
- 创建用于测试的数据文件
- 加载工程根目录,获取到所有文件
- 将每一个文件名,添加目录路径
- 打印所有文件名
参考代码
// 1. MainActor获取要进行单词统计的文件
val DIR_PATH = "./data/"
val dataDir = new File(DIR_PATH)
// 读取所有data目录下的所有文件
println("对以下文件进行单词统计:")
// 构建文件列表
val fileList = dataDir.list().toList.map(DIR_PATH + _)
println(fileList)
步骤2 | 创建WordCountActor
实现思路
根据文件数量创建WordCountActor,为了方便后续发送消息给Actor,将每个Actor与文件名关联在一起
实现步骤
- 创建WordCountActor
- 将文件列表转换为WordCountActor
- 为了后续方便发送消息给Actor,将Actor列表和文件列表拉链到一起
- 打印测试
参考代码
MainActor.scala
// 2. 根据文件数量创建对应的WordCountActor
val actorList = fileList.map {
x => new WordCountActor
}
// 将Actor和文件名列表建立为元组
val actorWithFileList: List[(WordCountActor, String)] = actorList.zip(fileList)
WordCountActor.scala
class WordCountActor extends Actor{
override def act(): Unit = {
}
}
步骤3 | 启动Actor/发送/接收任务消息
实现思路
启动所有WordCountActor,并发送单词统计任务消息给每个WordCountActor
[!NOTE]
此处应发送异步有返回消息
实现步骤
- 创建一个WordCountTask样例类消息,封装要进行单词计数的文件名
- 启动所有WordCountTask,并发送异步有返回消息
- 获取到所有的WordCount中获取到的消息(封装到一个Future列表中)
- 在WordCountActor中接收并打印消息
参考代码
MainActor.scala
// 3. 将文件名封装为消息发送给WordCountActor,并获取到异步返回结果
val futureList = actorWithFileList.map {
// tuple为Actor和文件名
tuple =>
// 启动actor
tuple._1.start()
// 发送任务消息
tuple._1 !! WordCountTask(tuple._2)
}
MessagePackage.scala
/**
* 单词统计任务消息
* @param fileName 文件名
*/
case class WordCountTask(fileName:String)
WordCountActor.scala
loop {
receive {
// 接收单词统计任务消息
case WordCountTask(fileName) => {
println("接收到消息:" + fileName)
}
}
}
步骤4 | 消息统计文件单词计数
实现思路
读取文件文本,并统计出来单词的数量。例如:
(hadoop, 3), (spark, 1)...
实现步骤
- 读取文件内容,并转换为列表
- 按照空格切割文本,并转换为一个一个的单词
- 为了方便进行计数,将单词转换为元组
- 按照单词进行分组,然后再进行聚合统计
- 打印聚合统计结果
参考代码
WordCountActor.scala
// 4. 统计单个文件的单词计数
val iter: Iterator[String] = Source.fromFile(fileName).getLines()
// [第一行] hadoop hadoop
// [第二行] hadoop spark
val lineList = iter.toList
// [单词列表] hadoop, hadoop, hadoop, spark
val wordList: List[String] = lineList.flatMap(_.split(" "))
// 将单词转换为元组
// [元组列表] (hadoop, 1), (hadoop, 1), (hadoop, 1), (spark, 1)
val tupleList = wordList.map(_ -> 1)
// 按照单词进行分组
// [单词分组] = {hadoop->List(hadoop->1, hadoop->1, hadoop->1), spark->List(spark ->1)}
val grouped: Map[String, List[(String, Int)]] = tupleList.groupBy(_._1)
// 将分组内的数据进行聚合
// [单词计数] = (hadoop, 3), (spark, 1)
val wordCount: Map[String, Int] = grouped.map {
tuple =>
// 单词
val word = tuple._1
// 进行计数
// 获取到所有的单词数量,然后进行累加
val total = tuple._2.map(_._2).sum
word -> total
}
println(wordCount)
步骤5 | 封装单词计数结果回复给MainActor
实现思路
- 将单词计数的结果封装为一个样例类消息,并发送给MainActor
- MainActor等待所有WordCount均已返回后获取到每个WordCountActor单词计算后的结果
实现步骤
- 定义一个样例类封装单词计数结果
- 将单词计数结果发送给MainActor
- MainActor中检测所有WordActor是否均已返回,如果均已返回,则获取并转换结果
- 打印结果
参考代码
MessagePackage.scala
/**
* 单词统计结果
* @param wordCount 单词计数
*/
case class WordCountResult(wordCount: Map[String, Int])
WordCountActor.scala
// 5. 将单词计数结果回复给MainActor
sender ! WordCountResult(wordCount)
MainActor.scala
// 等待所有Actor都已经返回
while(futureList.filter(_.isSet).size != fileList.size){}
// MainActor等待所有的WordCountActor都已经成功返回消息,然后进行结果合并
val resultList: List[Map[String, Int]] = futureList.map(_.apply.asInstanceOf[WordCountResult].wordCount)
println("接收到所有统计结果:" + resultList)
步骤6 | 结果合并
实现思路
对接收到的所有单词计数进行合并。因为该部分已经在WordCountActor已经编写过,所以抽取这部分一样的代码到一个工具类中,再调用合并得到最终结果
实现步骤
- 创建一个用于单词合并的工具类
- 抽取重复代码为一个方法
- 在MainActor调用该合并方法,计算得到最终结果,并打印
参考代码
WordCountUtil.scala
/**
* 单词分组统计
* @param wordCountList 单词计数列表
* @return 分组聚合结果
*/
def reduce(wordCountList:List[(String, Int)]) = {
// 按照单词进行分组
// [单词分组] = {hadoop->List(hadoop->1, hadoop->1, hadoop->1), spark->List(spark ->1)}
val grouped: Map[String, List[(String, Int)]] = wordCountList.groupBy(_._1)
// 将分组内的数据进行聚合
// [单词计数] = (hadoop, 3), (spark, 1)
val wordCount: Map[String, Int] = grouped.map {
tuple =>
// 单词
val word = tuple._1
// 进行计数
// 获取到所有的单词数量,然后进行累加
val total = tuple._2.map(_._2).sum
word -> total
}
wordCount
}
MainActor.scala
// 扁平化后再聚合计算
val result: Map[String, Int] = WordCountUtil.reduce(resultList.flatten)
println("最终结果:" + result)