Scala异步消息演示

注意要使用Actor,scala版本必须在2.10.
想起多年前的一个Android,IOS双机通信演示程序。
用的全局变量同步。
感觉用这个是不是更好点。

Messages.scala

package com.sensetime.asyncdemo

case object StartMessage
case object StartedMessage

case object StopMessage
case object StoppedMessage

case class AsyncMessage(val id: Int, val message: String)
case class ReplyMessage(val id: Int, val message: String)

AsyncMsgDemo.scala

package com.sensetime.asyncdemo

import scala.actors.Actor


// 用于实现消息接收的Actor类
object Actor4 extends Actor {
  override def act(): Unit = {

    while (true) {
      receive {
            // 接收到start消息，回返StartedMessage，可以开始通信了
        case StartMessage => {
          println("starting...")
          sender ! StartedMessage
        }
          // 接收到异步消息，打印消息，等待1秒，回返消息
        case AsyncMessage(id, message) => {
          println(s"id: $id, message: $message")
          Thread.sleep(1000)
          sender ! ReplyMessage(5, "success")
        }
          // 接收到停止消息，停止消息接收，退出
        case StopMessage => {
          println("stop message processing...")
          sender ! StoppedMessage
          return
        }
        case _ => println("wrong message, not process")
      }
    }
  }
}

object Actor3 extends Actor {

  // 类保留一个actor4实例
  val actor4 = Actor4


  override def act(): Unit = {
    // 消息发送标志位，置位后可发消息
    var sendMsgFlag = false
    // 发送一个 Start Message消息，启动消息循环，类似注册
    actor4 ! StartMessage

    var i = 0

    while (true) {
      // 如果消息位置位，可以发消息
      if (sendMsgFlag) {
        actor4 ! AsyncMessage(i, "异步消息")
        i += 1
      }

      // 仅发送10次，停止发送
      if (i == 10) {
        actor4 ! StopMessage
      }

      // 死等直到接收到某个消息
      receive {
            // 接收开始发送消息的消息
        case StartedMessage => {
          println("Start to send Message!!")
          // 置位消息发送标志
          sendMsgFlag = true
        }
          // 接收到异步消息的返回消息，打印消息
        case ReplyMessage(id, message) => {
          println(s"$id--> $message")
        }
          // 接收到停止消息，退出程序
        case StoppedMessage => {
          println("Message process has stopped...")
          // 收到StoppedMessage，直接return，让程序退出
          return
        }
      }
    }

  }
}

object AsyncMsgDemo {
  def main(args: Array[String]): Unit = {
    Actor3.start()
    Actor4.start()
  }
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>scala-actor-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-actors</artifactId>
            <version>2.10.5</version>
        </dependency>
    </dependencies>


</project>

输出