Scala中的Actor模型

岁月的眸

已于 2023-09-02 12:29:24 修改

阅读量913

点赞数

分类专栏： # Scala 文章标签： scala

于 2023-08-31 13:49:18 首次发布

本文链接：https://blog.csdn.net/m0_46168848/article/details/132601472

版权

Scala 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

本文介绍了Scala中的Actor模型，一种基于消息传递和非共享状态的并发编程模型，以及如何使用Akka库创建和管理Actors进行通信。通过示例展示了Actor的创建、消息传递和Actor间协作的方法。

摘要由CSDN通过智能技术生成

Scala中的Actor模型

概念

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

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

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

Actor的特征

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

具体写法

Actor发送接收消息

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之间通信

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 的创建和消息传递：

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 之间的相互协作：

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}")
}