《Scala并发编程》Actor生命周期示例

已于 2022-11-20 23:24:18 修改
阅读量156 收藏
点赞数
文章标签： scala java 开发语言
于 2022-11-19 23:32:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45101742/article/details/127943832
版权

《Scala并发编程》Actor生命周期示例

1.Actor 故障重启过程

package chapter08

import akka.actor.{Actor, ActorRef, Props}
import akka.event.Logging
import chapter08.scala01.ourSystem

object scala01_1_6  extends App {
  /**
   * 8.1.6 角色的生命周期
   *
   * @前文中的ChildActor类重载了postStop方法，用于在角色终止时输出一些日志信息。
   * @而本节将讨论postStop方法到底是在什么时机调用的，以及角色的生命周期里的其他重要事件。
   */


  /**
   * @为理解角色的生命周期的重要性，首先考虑一种情况，如果角色在处理消息时抛出一个异常，会发生什么？
   * @在Akka中，这样的异常被视为正常行为，所以顶层的用户角色抛出异常时会默认重启。
   * @重启会生产一个全新的角色对象，即角色状态会重新初始化。
   * @当角色重启之后，它的角色引用和角色路径是保持不变的。
   * @因而，同一个ActorRef对象只代表了逻辑意义下的同一个角色，其实际的物理角色对象有可能有多个。
   * @--@这也是角色绝不允许它的this引用泄露的原因，否则程序其他部分就会引用到旧的角色对象，于是让角色引用不再具有透明性。
   * @此外，暴露角色对象的this引用可能会暴露角色内部的实现细节，甚至会引起数据损坏。
   * 绝不要将角色对象的this引用传给其他角色，因为这会破坏角色的封装。
   */

  /**
   * 下面开始讨论完整的角色的生命周期。
   * @前文提到了，一个逻辑角色实例在调用actorOf方法时产生，
   * @Props对象用于实例化一个物理角色对象。这个对象会被指定一个邮箱，并且可以开始接收消息。
   * @actorOf方法向调用者返回一个角色引用，而所有的角色都可以并发地执行。
   */

  /**
   * @在角色开始处理消息之前，它的preStart方法会被调用，此方法用于初始化逻辑角色实例。
   * @角色创建完毕之后，它开始处理消息。
   * @在某个时刻，一个角色可能会因为异常而需要重启，这时，preRestart方法会被调用。
   * @然后，所有的子角色会被停止。
   * @随后，之前用于actorOf方法创建角色的那个Props对象会被重用，用于创建一个新的角色对象，
   * @并在新的角色对象上调用其postRestart方法。
   * @postRestart方法返回之后，新的角色对象的邮箱被指定为旧的角色对象的邮箱，它会继续处理重启之前邮箱中剩余的消息。
   */

  /**
   * @默认情况下，postRestart方法会调用preStart方法。
   * @在有些情况下，用户可能想修改这种行为。
   * @比如，数据库连接可能只需要在preStart中打开一次，并在逻辑角色实例停止时再关闭。
   * @一旦逻辑角色实例要停止了，postStop方法会被调用，角色的角色路径会被释放，并返回给角色系统。
   * @preRestart方法默认会调用postStop方法。完整角色的生命周期如图8.4所示。
   */

  /**
   * @注意，在角色的生命周期中，角色系统其他部分看到的是同一个角色引用，它不会因为角色重启而改变。
   * @角色的失败和重启对角色系统其他部分而言是不可见的。
   */

  /**
   * @为测试一个角色的生命周期，下面声明两个角色类，即StringPrinter和LifecycleActor。
   * @StringPrinter角色将它接收到的每个消息输出成日志。
   * @而它的preStart和postStop方法会被重载，以精确地追踪角色启动和终止的时机，如下面的代码所示。
   */
  class StringPrinter extends Actor {
    val log = Logging(context.system, this)
    def receive = {
      case msg => log.info(s"[${this.toString}] printer got message '$msg'")
    }
    override def preStart(): Unit = log.info(s"[print-${this.hashCode()}] printer preStart.")
    override def postStop(): Unit = log.info(s"[print-${this.hashCode()}] printer postStop.")
  }

  /**
   * @LifecycleActor类维护了一个指向StringPrinter角色的子角色引用。
   * @LifecycleActor类会响应Double和Int消息，并输出；
   * @也可以响应List消息，并输出链表的第一个元素。
   * @当LifecycleActor实例收到一个String消息时，它会将其转发给它的子角色。
   */
  class LifecycleActor extends Actor {
    val log = Logging(context.system, this)
    var child: ActorRef = _
    def receive = {
      case num: Double => log.info(s"got a double - $num")
      case num: Int => log.info(s"got an integer - $num")
      case lst: List[_] => log.info(s"list - ${lst.head}, ...")
      case txt: String => child ! txt
    }

    /**
     * @下面要重载其生命周期钩子函数。首先是preStart方法，它用于输出一个日志，并实例化子角色。
     * @这保证了子角色引用在子角色开始处理消息之前就初始化完成了。
     */
    override def preStart(): Unit = {//和receive是同步的
      log.info(s"[life-${this.hashCode()}] about to start")
      child = context.actorOf(Props[StringPrinter], "kiddo")

    }

    /**
     * @接下来重载preRestart和postRestart方法。在这两个方法中，会输出失败的原因。
     * @postRestart方法默认会调用preStart方法，以便让新的角色对象在重启之后初始化得到一个新的子角色对象。
     */
    override def preRestart(t: Throwable, msg: Option[Any]): Unit = {
      log.info(s"[life-${this.hashCode()}] about to restart because of $t, during message $msg")
      super.preRestart(t, msg)
    }
    override def postRestart(t: Throwable): Unit = {
      log.info(s"[life-${this.hashCode()}] just restarted due to $t")
      super.postRestart(t)
    }

    /**
     * @重载postStop方法，用于追踪角色终止的时机。
     */
    override def postStop() = log.info(s"[life${this.hashCode()}] just stopped")

    /**
     * @现在，创建一个LifecycleActor类的实例testy，并向其发送消息math.Pi。
     * @此角色会在preStart方法中输出about-to-start的信息，创建一个新的子角色。
     * @然后输出它接收到的消息math.Pi。
     * @注意，该角色的about-to-start日志信息是在math.Pi消息被接收到之后输出来的。
     * @这表明角色创建过程是异步操作：当调用actorOf时，创建出的角色会由角色系统代理，然后程序立即开始执行。
     */
  }

  val testy = ourSystem.actorOf(Props[LifecycleActor], "testy")
  //Thread.sleep(2000)
  //testy ! math.Pi

  /**
   * 向testy发送一个字符串消息，此消息会被转发给子角色，子角色接收到消息之后在日志记录中输出。
   */
  //testy ! "hi there!"

  /**
   * @向testy发送Nil消息，此对象表示一个空链表，所以testy在尝试获取第一个元素时抛出一个异常。
   * @这时角色汇报它需要重启，随后可以看到子角色也要重启的消息。
   * @因为前文提到过，当一个角色重启时，子角色会被停止。
   * @最后，testy会输出它将要重启的消息，而新的子角色也将初始化。这些事件都源自下面这条语句。
   */
  testy ! Nil

  /**
   * @测试角色的生命周期揭示了actorOf方法的一个重要性质，即调用actorOf方法时，执行过程会继续，而不会等待角色充分初始化完毕。
   * @类似地，发送一个消息不会阻塞执行过程，无论其他角色是否接收到或处理，执行过程都会继续。
   * @这种消息称为异步消息。8.2节将介绍多种通信模式中是如何处理这种异步消息的。
   */

}

在这里插入图片描述


[INFO] [11/19/2022 22:28:13.388] [OurExampleSystem-akka.actor.default-dispatcher-4] [akka://OurExampleSystem/user/testy] [life-1225620711] about to start
[INFO] [11/19/2022 22:28:13.390] [OurExampleSystem-akka.actor.default-dispatcher-2] [akka://OurExampleSystem/user/testy/kiddo] [print-1656787776] printer preStart.
[ERROR] [11/19/2022 22:28:13.397] [OurExampleSystem-akka.actor.default-dispatcher-2] [akka://OurExampleSystem/user/testy] head of empty list
java.util.NoSuchElementException: head of empty list
	at scala.collection.immutable.Nil$.head(List.scala:420)
	at scala.collection.immutable.Nil$.head(List.scala:417)
	at chapter08.scala01_1_6$LifecycleActor$$anonfun$receive$2.applyOrElse(scala01_1_6.scala:83)
	at akka.actor.Actor$class.aroundReceive(Actor.scala:497)
	at chapter08.scala01_1_6$LifecycleActor.aroundReceive(scala01_1_6.scala:77)
	at akka.actor.ActorCell.receiveMessage(ActorCell.scala:526)
	at akka.actor.ActorCell.invoke(ActorCell.scala:495)
	at akka.dispatch.Mailbox.processMailbox(Mailbox.scala:257)
	at akka.dispatch.Mailbox.run(Mailbox.scala:224)
	at akka.dispatch.Mailbox.exec(Mailbox.scala:234)
	at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:260)
	at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1339)
	at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1979)
	at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:107)

[INFO] [11/19/2022 22:28:13.398] [OurExampleSystem-akka.actor.default-dispatcher-4] [akka://OurExampleSystem/user/testy] [life-1225620711] about to restart because of java.util.NoSuchElementException: head of empty list, during message Some(List())
[INFO] [11/19/2022 22:28:13.400] [OurExampleSystem-akka.actor.default-dispatcher-4] [akka://OurExampleSystem/user/testy] [life1225620711] just stopped
[INFO] [11/19/2022 22:28:13.401] [OurExampleSystem-akka.actor.default-dispatcher-3] [akka://OurExampleSystem/user/testy/kiddo] [print-1656787776] printer postStop.
[INFO] [11/19/2022 22:28:13.402] [OurExampleSystem-akka.actor.default-dispatcher-4] [akka://OurExampleSystem/user/testy] [life-1406877080] just restarted due to java.util.NoSuchElementException: head of empty list
[INFO] [11/19/2022 22:28:13.403] [OurExampleSystem-akka.actor.default-dispatcher-4] [akka://OurExampleSystem/user/testy] [life-1406877080] about to start
[INFO] [11/19/2022 22:28:13.403] [OurExampleSystem-akka.actor.default-dispatcher-2] [akka://OurExampleSystem/user/testy/kiddo] [print-32583356] printer preStart.

其中 1、2、3、4、5都是线性化的，postRestart方法返回之后，新的角色对象的邮箱被指定为旧的角色对象的邮箱，它会继续处理重启之前邮箱中剩余的消息。
对比线程的HashCode 值 可以确定actor更替时间

2.Actor 停止方法 context.stop

请添加图片描述
角色终止调用的是context.stop。调用上下文对象上的stop方法会让角色在处理完当前消息之后立刻停止。
可以看到调用了context.stop(self) 等待receive方法的完成后 再停止

样柏
关注
Rust中的并发编程
AI天才研究院
07-30 1299
Rust 语言是一种安全、快速、且拥有惊人的性能优势的系统级编程语言。相比 C 和 C++等传统的编程语言而言，Rust 增加了很多高级特性，如模式匹配、迭代器、trait 对象等。这些特性使得 Rust 在编写系统软件时变得异常方便和舒适。为什么要学习 Rust 的并发编程？Rust 是目前最热门的系统级编程语言之一；Rust 有着独特的内存管理机制，可以自动处理内存分配和释放，让程序员不必担心内存泄漏的问题；Rust 提供了多线程、异步编程模型，可以轻松编写出健壮、可靠、高效率的并发程序；
Actor生命周期
qq_32461003的博客
10-12 489
 要使用Akka Actor类型，您必须在项目中添加以下依赖项: <properties> <akka.version>2.6.10</akka.version> <scala.binary.version>2.13</scala.binary.version> </properties> <dependency> <groupId>com.typesafe.akka</groupId>
《Scala并发编程》Actor监管示例
weixin_45101742的博客
11-21 141
《Scala并发编程》Actor监管示例
Scala的Actor模型：并发编程的革命性抽象 摘要
2401_85760095的博客
06-29 779
Scala语言以其强大的函数式编程特性和并发模型而闻名。Actor模型作为Scala并发编程的核心，提供了一种高效、可靠的并行处理方式。本文将深入探讨Scala的Actor模型，包括其设计理念、实现机制以及如何在实际应用中使用Actor模型进行并发编程。
【scala专栏_持续更新】29_scalaActor并发编程
专注大数据与自由
11-20 684
【大纲】 【正文】 1.特点 0.scala的Actor并发编程模型，是基于事件模型的并发机制，不共享数据，依赖消息传递。可有效避免资源争夺、死锁，比java多线程效率更高 1.scala在2.11.x版本由Akka并发编程框架代替了Actor 2.使用示例--并发词频统计：统计3个文件中的单词的词频汇总，则创建3个Actor，一人一个文件，并发去分别统计3个文件的词频，等都统计完成后，回收结果给主Actor，进行汇总计算 2.Actor多线程 2.1.代码步骤 0.定义一个class或object
scala--Akka并发编程-了解-★
qq_46893497的博客
03-07 286
Akka并发编程-了解-★概述Akka的特性应用编程模型-了解API-了解-不用记准备环境Akka案例-1-简单RPC-尽量掌握流程-★★需求--掌握代码实现-Master代码实现-WorkerAkka案例-2-模拟SparkRPC通信-尽量掌握流程-★★需求分析-掌握-★★代码实现-1-样例类代码实现-2-信息存储类代码实现-3-Master代码实现-4-Worker 概述 Akka是基于Scala的Actor-API做进一步封装,实现的一个并发编程框架! 可以让并发编程更简单!—但是实际使用起来好像并
Scala Actor通信
Tao_cuichen的博客
04-10 3513
Scala Actor通信         简介 Actor提供了并发程序中与传统的基于锁的结构不同的另一种选择。通过尽可能避免锁和共享状态，Actor使得我们能够更加容易设计出正确、没有死锁或争用状态的程序。Scala类库提供了一个Actor模型的简单实现，除此之外还有其他更高级的Actor类库，比如Akka(http://akka.io)。     创建和启动Actor a
【scala专栏_持续更新】30_scalaAkka并发编程
专注大数据与自由
11-20 348
【大纲】 【正文】 1.特点 0.Akka是一个高并发、分布式、可扩展的，基于事件驱动的scala并发编程库，源码是单独的不在scala中。可以使用scala或java语言来调用Akka库 1.异步非阻塞、高性能的基于事件驱动的编程模型 2.内置容错机制，Actor出错时可进行恢复或重置？ 3.超轻量级事件处理，每G堆内存能存几百万Actor对象，每个Actor对象独立占用一个线程 4.使用Akka可在单机上构建高并发程序，也可在网络中构建分布式并发程序 # 注意：Akka也是基
Akka框架：Scala并发编程的瑞士军刀
2401_85439108的博客
06-28 618
Akka是一个构建并发、分布式和容错应用程序的工具包和运行时。它以Actor模型为基础，提供了一种高效、可扩展的方式来处理并发任务。Akka框架为Scala并发编程提供了强大的支持，通过Actor模型简化了并发任务的处理。本文介绍了Akka的核心概念、组件以及如何在Scala中使用Akka进行并发编程。理解Akka的工作原理和使用方式，可以帮助开发者构建高效、可扩展和容错的应用程序。通过实际代码示例，我们了解了如何在Akka中创建Actor、发送消息、处理异步操作以及实现Actor的生命周期管理。
scala并发编程开发教程
11-14
在Akka中，`ActorSystem`是Actor的容器，它管理Actor的生命周期和调度。由于`ActorSystem`消耗资源较多，通常设计为单例，以优化资源利用。我们可以通过`ActorSystem`来创建和管理Actor。 `Actor`类是实际执行工作...
scala编程的实战
04-09
- `preStart()`：在Actor对象构造方法执行后执行，整个Actor生命周期中仅执行一次。 - `receive()`：在Actor的`preStart`方法执行完成后执行，用于接收消息，会被反复执行。 - **Master类**：作为集群中的主节点，...
Scala编程：Actors实现高效并发软件
- **Actor生命周期**：Actors有创建、活动、停止等生命周期阶段。可以使用`ActorSystem`来创建和管理Actor，当不再需要Actor时，可以通过`stop`方法优雅地停止它，释放相关资源。 - **Actor上下文**：每个Actor都有...
Akka Scala编程指南：高并发与容错系统
- **Actor System**：actor的组织结构，管理actor的生命周期和资源。 - **Supervision and Monitoring**：演员树的监督策略，确保在出现故障时能够恢复或重启演员。 - **Dispatcher**：负责将消息分发到worker...
2. Flink快速上手
howard2005的专栏
10-29 301
通过今天的实战，您应该已经了解了如何快速上手Apache Flink，并进行简单的批处理和流处理操作。希望这些内容能够帮助您在实际项目中更好地使用Flink。
记本地第一次运行seatunnel示例项目
大尾猴的博客
10-30 481
静态源码编译通过：https://blog.csdn.net/u011924665/article/details/143372464。
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 801
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1368
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 854
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 247
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值