[翻译]AKKA笔记 - ACTOR生命周期 - 基本 -5

原文地址:http://rerun.me/2014/10/21/akka-notes-actor-lifecycle-basic/

(请注意这了讨论的生命周期并不包括 preRestart 或者postRestart方法,当我们讨论supervision时候我们会说这个)

基本的Actor生命周期很直观。除了一点小不同,你可以直接拿基本Actor生命周期与Java Servlet生命周期作比较。

  1. 像其他常规类一样,我们有一个构造函数。
  2. preStart方法会被调用。 这里你可以在postStop初始化一些稍后你想清理的资源。
  3. receive方法用作服务或者消息处理,占用了大部分时间。

先看下一个打印了生命周期的简单actor。

DUMB LIFECYCLE ACTOR

    package me.rerun.akkanotes.lifecycle

    import akka.actor.{ActorLogging, Actor}
    import akka.event.LoggingReceive

    class BasicLifecycleLoggingActor extends Actor with ActorLogging{

      log.info ("Inside BasicLifecycleLoggingActor Constructor")
      log.info (context.self.toString())
      override def preStart() ={
        log.info("Inside the preStart method of BasicLifecycleLoggingActor")
      }

      def receive = LoggingReceive{
        case "hello" => log.info ("hello")
      }

      override def postStop()={
        log.info ("Inside postStop method of BasicLifecycleLoggingActor")
      }

    }

APP

LifecycleApp只初始化,发一个消息给Actor然后关掉ActorSystem.

import akka.actor.{ActorSystem, Props}

object LifecycleApp extends App{

  val actorSystem=ActorSystem("LifecycleActorSystem")
  val lifecycleActor=actorSystem.actorOf(Props[BasicLifecycleLoggingActor],"lifecycleActor")

  lifecycleActor!"hello"

  //wait for a couple of seconds before shutdown
  Thread.sleep(2000)
  actorSystem.shutdown()

 }

输出

Inside BasicLifecycleLoggingActor Constructor

Actor[akka://LifecycleActorSystem/user/lifecycleActor#-2018741361]

Inside the preStart method of BasicLifecycleLoggingActor

hello

Inside postStop method of BasicLifecycleLoggingActor  

那个在基础Actor生命周期与Servlet生命周期的一点不同是什么?

Actor生命周期中的构造函数和preStart是没什么不一样的。

我把context.self在构造函数中进行打印的原因就是 - 不像Servlets,Actor在构造函数中可以访问到ActorContext。而preStart与构造函数间的差别就很微妙了。如果你要打破砂锅问到底,我们再看下之前说的不同 - 当Actor重启时(失败的case)调用preStart是可控的。 用构造函数就不可能了。

什么时候POSTSTOP会被调用?

像我们前面看到的程序, postStrop在ActorSystem关闭时会被调用。还有很多其他的机会能调用到这个回调。

1.ACTORSYSTEM.STOP()

我们可以用ActorSystem的stop方法来停止一个ActorActorContext

object LifecycleApp extends App{

  val actorSystem=ActorSystem("LifecycleActorSystem")
  val lifecycleActor=actorSystem.actorOf(Props[BasicLifecycleLoggingActor],"lifecycleActor")

  actorSystem.stop(lifecycleActor);

  ...
  ...

} 

2.ACTORCONTEXT.STOP

* 1)可以传个消息(外部或自己给自己传)*

class BasicLifecycleLoggingActor extends Actor with ActorLogging{
...
...
  def receive = LoggingReceive{
    case "hello" => log.info ("hello")
    case "stop" => context.stop(self)
  }

object LifecycleApp extends App{

  val actorSystem=ActorSystem("LifecycleActorSystem")
  val lifecycleActor=actorSystem.actorOf(Props[BasicLifecycleLoggingActor],"lifecycleActor")

  lifecycleActor!"stop"
...
...

** 2)或无原因的把自己杀掉(这只是为了好玩。没有一个有追求的Actor会这么做)

class BasicLifecycleLoggingActor extends Actor with ActorLogging{

  log.info ("Inside BasicLifecycleLoggingActor Constructor")
  log.info (context.self.toString())
  context.stop(self)
  ...
  ...

3.毒药

在之前的例子,我们从LifecycleApp给Actor传了一个叫stop的消息。Actor在收到消息后用context.stop把自己杀掉。我们也可以通过传递一个毒药(PoisonPill)消息到目标actor来达到同样的目的。请记住这个毒药消息,会像前面的stop消息一样被放在常规mailbox中,当被处理到的时候才会运行。

object LifecycleApp extends App{

  val actorSystem=ActorSystem("LifecycleActorSystem")
  val lifecycleActor=actorSystem.actorOf(Props[BasicLifecycleLoggingActor],"lifecycleActor")

  lifecycleActor!PoisonPill
  ...
  ...

4.KILL

除了发送一个毒药(PoisonPill), 你也可以给目标Actor发送一个kill消息。

lifecycleActor ! Kill  

发送毒药消息和kill消息,区别很微妙但很重要。

  1. PoisonPill,一个Terminated消息会被发送到所有的watcher(稍后我们会在DeathWatch章节中看到)
  2. 发送kill消息,宿主Actor会抛出一个ActorKilledException并被发送给Supervisor(稍后我们会在Supervision章节中看到)

细枝末节

我前面说的常规mailbox是啥意思?是否还有个“特别”mailbox?是的,确实有!我们会在讨论supervision和system消息时说到这个。


TERMINATION

当Actor停止时,他会进入一个Terminated状态。你马上就会想到一个问题,那些发到一个已经是terminated状态的Actor的消息会怎么样?

让我们看看:

APP

object LifecycleApp extends App{

  val actorSystem=ActorSystem("LifecycleActorSystem")
  val lifecycleActor=actorSystem.actorOf(Props[BasicLifecycleLoggingActor],"lifecycleActor")

  lifecycleActor!"hello"
  lifecycleActor!"stop"
  lifecycleActor!"hello" //Sending message to an Actor which is already stopped

}

ACTOR - 与之前一样

class BasicLifecycleLoggingActor extends Actor with ActorLogging{

  def receive = LoggingReceive{
    case "hello" => log.info ("hello")
    case "stop" => context.stop(self)

  }
}

输出

BasicLifecycleLoggingActor - hello 

akka.actor.RepointableActorRef - Message [java.lang.String] from Actor[akka://LifecycleActorSystem/deadLetters] to Actor[akka://LifecycleActorSystem/user/lifecycleActor#-569230546] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.  

从日志中可以看到,这里对deadletters有一些引用。任何你发给那个已经terminated的Actor的消息都会转发给一个叫DeadLetterActor的内部Actor的mailbox。


那么这之后又发生了什么?

DeadLetter Actor处理它mailbox里的消息,把每个消息都封装成一个DeadLetter并且把它发布到EventStream中。

另一个叫DeadLetterListener的Actor消费所有的DeadLetter并把它输出成日志消息。从这里看

记住,当我们说日志的时候,我们可以看到所有输出到EventStream的消息并且可以随意消费 - 只是这个消费者一样必须是个Actor。让我们试试。

在我们的例子中,我们消费EventStream并且观看所有DeadLetter消息最后打印到console(这没有创造力??)当然,我们还能自由的做任何事如生成告警,把它保存到数据库或把它拿去作分析。

订阅EVENTSTREAM的DEADLETTERS

import akka.actor.ActorSystem
import akka.actor.Props
import akka.actor.PoisonPill
import akka.actor.DeadLetter
import akka.actor.Actor

object LifecycleApp extends App {

  val actorSystem = ActorSystem("LifecycleActorSystem")
  val lifecycleActor = actorSystem.actorOf(Props[BasicLifecycleLoggingActor], "lifecycleActor")

  val deadLetterListener = actorSystem.actorOf(Props[MyCustomDeadLetterListener])
  actorSystem.eventStream.subscribe(deadLetterListener, classOf[DeadLetter])

  lifecycleActor ! "hello"
  lifecycleActor ! "stop"
  lifecycleActor ! "hello"

}

class MyCustomDeadLetterListener extends Actor {
  def receive = {
    case deadLetter: DeadLetter => println(s"FROM CUSTOM LISTENER $deadLetter")
  }
}

输出

164  [LifecycleActorSystem-akka.actor.default-dispatcher-4] INFO  BasicLifecycleLoggingActor - hello 

167  [LifecycleActorSystem-akka.actor.default-dispatcher-4] INFO  akka.actor.RepointableActorRef - Message [java.lang.String] from Actor[akka://LifecycleActorSystem/deadLetters] to Actor[akka://LifecycleActorSystem/user/lifecycleActor#-782937925] was not delivered. [1] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'. 

FROM CUSTOM LISTENER DeadLetter(hello,Actor[akka://LifecycleActorSystem/deadLetters],Actor[akka://LifecycleActorSystem/user/lifecycleActor#-782937925])  


文章来自微信平台「麦芽面包」(微信扫描二维码关注)。未经允许,禁止转载。

时间: 2024-10-26 05:34:19

[翻译]AKKA笔记 - ACTOR生命周期 - 基本 -5的相关文章

[翻译]AKKA笔记 - DEATHWATCH -7

当我们说Actor生命周期的时候,我们能看到Actor能被很多种方式停掉(用ActorSystem.stop或ActorContext.stop或发送一个PoisonPill - 也有一个kill和gracefulstop). 无论Actor是怎么死的,有些情况一些系统中的其他actor想要知道.让我们举一个Actor与数据库交互的例子 - 我们叫它RepositoryActor.很明显,会有一些其他actor会向这个RepositoryActor发送消息.这些有"兴趣"的Actor很

Actor生命周期理解

Actor生命周期理解 镇图:Actor内功心法图 Actor的生命周期可以用Hooks体现和控制,下面是默认的Actor Hooks的方法,我们可以选择性的进行重写: def preStart(): Unit = () def postStop(): Unit = () def preRestart(reason: Throwable, message: Option[Any]): Unit = { context.children foreach { child ⇒ context.unwa

翻译:AKKA笔记 - Actor消息 -1(一)

从第一篇Akka笔记的介绍中,我们是从很高的高度去观察Akka工具箱中的Actors.在这篇笔记的第二篇,我们会看一下Actors中的消息部分.而且延续上一次的例子,我们还会使用同样的学生与老师的例子. 在Actor消息的第一部分,我们会建立一个Teacher Actor,而且会使用一个叫StudentSimulatorApp的主程序. 回顾学生-老师模式的细节 现在考虑下StudentSimulatorApp单独发消息给TeacherActor.当我说到StudentSimulatorApp,

[翻译]AKKA笔记 - CHILD ACTORS与ACTORPATH -6

原文:http://rerun.me/2014/10/21/akka-notes-child-actors-and-path/ Actor是完全的继承结构.你创建的任何Actor肯定都是一个其他Actor的child. 让我们分析下: PATH 我们用ActorSystem.actorof创建一个ActorRef并打印出他的path val actorSystem=ActorSystem("SupervisionActorSystem") val actorRef=actorSyste

Java Servlet Programming 读书笔记 - servlet生命周期

servlet|笔记 servlet的生命周期一般为: 1.建立初始化servlet 2.处理从客户端的零个或多个请求 3.销毁servlet,gc回收占用内存 每个server可能在如何支持servlet上有不同的方法,但是上述servlet生命周期却是每个servlet 引擎必须遵守的规则. 实例持久化Instance Persistence: 一个servlet 实例一旦加载,就开始处理对这个servlet的所有请求,换句话说就是一个servlet只生成一个实例.这样的做法对于性能的提高很

翻译:AKKA笔记 - 介绍Actors

任何以前做过多线程的人都不会否认管理多线程程序是困难并且痛苦的. 我说管理是因为它开始很容易而且当你看到性能提升时会很兴奋.但是,当你看到你没法从子线程的错误中恢复 或者 这些僵尸bug很难重现 或者 当用性能剖析器时你发现你的线程在更新一个共享状态时阻塞了很长时间时,那真的很痛苦. 我倾向于不说Java的并发API和集合把并发编程变的更轻松和容易了,因为如果你看到这,你肯定渴望对子线程任务有更多控制或者希望更简单但又不愿意去写一堆的锁和同步代码块,而且希望对这种模式有更高层的抽象. 着这个Ak

Android开发艺术探索笔记——第一章:Activity的生命周期和启动模式

Android开发艺术探索笔记--第一章:Activity的生命周期和启动模式 怀着无比崇敬的心情翻开了这本书,路漫漫其修远兮,程序人生,为自己加油! 一.序 作为这本书的第一章,主席还是把Activity搬上来了,也确实,和Activity打交道的次数基本上是最多的,而且他的内容和知识点也是很多的,非常值得我们优先把他掌握,Activity中文翻译过来就是"活动"的意思,但是主席觉得这样翻译有些生硬,直接翻译成"界面"可能更好,的确,Activity主要也是用于U

Akka笔记之Actor简介

英文原文链接,译文链接,原文作者:Arun Manivannan ,译者:有孚 写过多线程的人都不会否认,多线程应用的维护是件多么困难和痛苦的事.我说的是维护,这是因为开始的时候还很简单,一旦你看到性能得到提升就会欢呼雀跃.然而,当你发现很难从子任务的错误中恢复或者有些僵尸BUG很难复现再或者你的分析器显示你的线程在写入一个共享状态前大部分时间都浪费在阻塞上面的时候,痛苦降临了. 我刻意没提Java的并发API,以及它里面的集合类使得多线程编程变得多么轻松简单,因为我相信既然你们点进了这篇文章,

MAVEN学习笔记之Maven生命周期和插件简介(3)

MAVEN学习笔记之Maven生命周期和插件简介(3) clean compile site三套生命周期相互独立. clean pre-clean 执行清理前的工作 clean 清理上一次构建生成的所有文件 post-clean 执行清理后的工作 compile validate generate-sources process-sources generate-resources process-sources process-resources 复制并处理资源文件,至目标目录,准备打包 co