scala-5 Actor基于事件并发的编程模型

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中创建线程很类似，也是通过继承来创建。

使用方式

1. 定义class或object继承Actor特质
2. 重写act方法
3. 调用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()
  }

object是单例，同一个object无法实现并发

object ActorDemo {

  class ActorTest01(var startFrom: Int) extends Actor {
    override def act(): Unit = {
      for (i <- 1 to startFrom) {
        println(Thread.currentThread().getName + ": " + i)
        Thread.sleep(500)
      }
    }
  }

  object ActorTest02 extends Actor {
    override def act(): Unit = {
      for (i <- 1 to 5) {
        println(Thread.currentThread().getName + ": " + i)
        Thread.sleep(500)
      }
    }
  }

  object ActorTest03 extends Actor {
    override def act(): Unit = {
      for (i <- 1 to 5) {
        println(Thread.currentThread().getName + ": " + i)
        Thread.sleep(500)
      }
    }
  }

  def main(args: Array[String]): Unit = {
    //new ActorTest01(5).start()
    //new ActorTest01(5).start()

    /** result
     * ForkJoinPool-1-worker-13: 1
     * ForkJoinPool-1-worker-11: 1
     * ForkJoinPool-1-worker-13: 2
     * ForkJoinPool-1-worker-11: 2
     * ForkJoinPool-1-worker-11: 3
     * ForkJoinPool-1-worker-13: 3
     * ForkJoinPool-1-worker-11: 4
     * ForkJoinPool-1-worker-13: 4
     * ForkJoinPool-1-worker-13: 5
     * ForkJoinPool-1-worker-11: 5
     */


    //ActorTest02.start()
    //ActorTest02.start()

    /** result
     * ForkJoinPool-1-worker-13: 1
     * ForkJoinPool-1-worker-13: 2
     * ForkJoinPool-1-worker-13: 3
     * ForkJoinPool-1-worker-13: 4
     * ForkJoinPool-1-worker-13: 5
     */

    ActorTest02.start()
    ActorTest03.start()

    /** result
     * ForkJoinPool-1-worker-13: 1
     * ForkJoinPool-1-worker-11: 1
     * ForkJoinPool-1-worker-11: 2
     * ForkJoinPool-1-worker-13: 2
     * ForkJoinPool-1-worker-11: 3
     * ForkJoinPool-1-worker-13: 3
     * ForkJoinPool-1-worker-11: 4
     * ForkJoinPool-1-worker-13: 4
     * ForkJoinPool-1-worker-13: 5
     * ForkJoinPool-1-worker-11: 5
     */
  }
}

Actor程序运行流程

1. 调用start()方法启动Actor
2. 自动执行act()方法
3. 向Actor发送消息
4. 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并发编程来统计单词的数量

思路分析

实现思路

1. MainActor获取要进行单词统计的文件
2. 根据文件数量创建对应的WordCountActor
3. 将文件名封装为消息发送给WordCountActor
4. WordCountActor接收消息，并统计单个文件的单词计数
5. 将单词计数结果发送给MainActor
6. MainActor等待所有的WordCountActor都已经成功返回消息，然后进行结果合并

步骤1 | 获取文件列表

实现思路

在main方法中读取指定目录(${project_root_dir}/data/)下的所有文件，并打印所有的文件名

实现步骤

1. 创建用于测试的数据文件
2. 加载工程根目录，获取到所有文件
3. 将每一个文件名，添加目录路径
4. 打印所有文件名

参考代码

// 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与文件名关联在一起

实现步骤

1. 创建WordCountActor
2. 将文件列表转换为WordCountActor
3. 为了后续方便发送消息给Actor，将Actor列表和文件列表拉链到一起
4. 打印测试

参考代码

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]

此处应发送异步有返回消息

实现步骤

1. 创建一个WordCountTask样例类消息，封装要进行单词计数的文件名
2. 启动所有WordCountTask，并发送异步有返回消息
3. 获取到所有的WordCount中获取到的消息（封装到一个Future列表中）
4. 在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)...

实现步骤

1. 读取文件内容，并转换为列表
2. 按照空格切割文本，并转换为一个一个的单词
3. 为了方便进行计数，将单词转换为元组
4. 按照单词进行分组，然后再进行聚合统计
5. 打印聚合统计结果

参考代码

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单词计算后的结果

实现步骤

1. 定义一个样例类封装单词计数结果
2. 将单词计数结果发送给MainActor
3. MainActor中检测所有WordActor是否均已返回，如果均已返回，则获取并转换结果
4. 打印结果

参考代码

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已经编写过，所以抽取这部分一样的代码到一个工具类中，再调用合并得到最终结果

实现步骤

1. 创建一个用于单词合并的工具类
2. 抽取重复代码为一个方法
3. 在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)