Scala中的Actor模型

概念

Actor Model是用来编写并行计算或分布式系统的高层次抽象（类似java中的Thread）让程序员不必为多线程模式下共享锁而烦恼。Actors将状态和行为封装在一个轻量的进程/线程中，但是不和其他Actors分享状态，每个Actors有自己的世界观，当需要和其他Actors交互时，通过发送事件和消息，发送是异步的，非堵塞 的(fire-andforget)，发送消息后不必等另外Actors回复，也不必暂停，每个Actors有自己的消息队列，进来的消息按先来后到排列，这就有很好的并发策略和可伸缩性，可以建立性能很好的事件驱动系统。

2.12版本后，actor彻底从scala中抽离了出来，所以我们在使用前需要引入相应的lib。

xml 复制代码

<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-actor_2.12</artifactId>
    <version>2.5.9</version>
</dependency>

Actor的特征

ActorModel是消息传递模型,基本特征就是消息传递
消息发送是异步的，非阻塞的
消息一旦发送成功，不能修改
Actor之间传递时，接收消息的actor自己决定去检查消息，actor不是一直等待，是异步非阻塞的

具体写法

Actor发送接收消息

scala 复制代码

import akka.actor.Actor
import akka.actor.ActorSystem
import akka.actor.Props

class HelloActor extends Actor {
  override def receive: Receive = {
    case "hey" => println("hey yourself")
    case _ => println("hehe")
  }
}

object Main extends App {
  val system = ActorSystem("HelloSystem")
  val helloActor = system.actorOf(Props[HelloActor], name = "helloActor")
  helloActor ! "hey"
  helloActor ! "good morning"
}

Actor与Actor之间通信

scala 复制代码

import akka.actor.{Actor, ActorRef, ActorSystem, Props}

class MyActor extends Actor {
  override def receive: Receive = {
    case msg: String => {
      println(msg)
      Thread.sleep(1000)
      sender() ! "你说啥"
    }
    case Int => println("你竟然说数字")
    case _ => println("default")
  }
}
class MyActor2 extends Actor {
  private val other: ActorRef = context.actorOf(Props(new MyActor), "actor1child")
  override def receive: Receive = {
    case msg: String => {
      println(msg)
      other ! "nihao"
    }
  }
}
object Test extends App {
  private val system: ActorSystem = ActorSystem("system")
  private val actor: ActorRef = system.actorOf(Props(new MyActor2), "actor1")
  actor ! "你好actor2"
}

综述

Scala 中的 Actor 模型是一种并发编程模型，用于处理并发和并行计算。Actor 模型的核心概念是基于消息传递和非共享状态，并通过轻量级的执行单元（称为 Actor）来实现并发和协作。

在 Scala 中，可以使用 Akka 框架来实现 Actor 模型。Akka 是一个构建可扩展、高性能和弹性系统的工具包，它提供了强大的 Actor 模型库。

下面是一些关于 Scala 中 Actor 模型的基本概念和用法：

Actor 的创建和消息传递：

scala 复制代码

import akka.actor.{Actor, ActorSystem, Props}

class MyActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Received message: $message")
  }
}

val system = ActorSystem("MySystem")
val myActor = system.actorOf(Props[MyActor], "myActor")

myActor ! "Hello"

在上述示例中，我们定义了一个 MyActor 类，它继承自 Actor 并重写了 receive 方法来处理消息。通过 ActorSystem 和 Props，我们创建了一个名为 "MySystem" 的 Actor 系统，并创建了一个名为 "myActor" 的 Actor 实例。然后，我们通过 ! 运算符向 myActor 发送了一条消息 "Hello"。

Actor 之间的相互协作：

scala 复制代码

class GreetingActor extends Actor {
  def receive: Receive = {
    case message: String =>
      val senderActor = sender()
      println(s"GreetingActor received message: $message")
      senderActor ! "Nice to meet you"
  }
}

val greetingActor = system.actorOf(Props[GreetingActor], "greetingActor")
val response = myActor.ask("How are you?")(timeout = Timeout(5.seconds)).mapTo[String]

response.onComplete {
  case Success(message) => println(s"Response: $message")
  case Failure(ex) => println(s"Failed: ${ex.getMessage}")
}

在上述示例中，我们创建了一个 GreetingActor 类，它也是一个 Actor。在 receive 方法中，它接受到消息后会打印出接收到的消息，并通过 sender() 方法获取发送消息的 Actor，并向其发送一条回复消息。

在主程序中，我们使用 ask 方法向 myActor 发送一个问候消息并等待回复。通过 mapTo 方法，将回复消息转换为字符串类型，并使用 onComplete 处理回复结果。

总之，Scala 中的 Actor 模型提供了一种高效且易于编写并发代码的方式。Akka 框架为 Scala 提供了完善的 Actor 模型实现，使我们能够轻松构建并发和并行计算应用程序。