[翻译]AKKA笔记 -ACTOR SUPERVISION - 8

失败更像是分布式系统的一个特性。因此Akka用一个容忍失败的模型，在你的业务逻辑与失败处理逻辑(supervision逻辑)中间你能有一个清晰的边界。只需要一点点工作，这很赞。这就是我们要讨论的主题。

ACTOR SUPERVISION

想象一个方法调用了你栈顶的方法但却出了一个异常。那么在栈下的方法能做什么呢？

1. 抓住异常并按顺序处理恢复

2. 抓住异常，也许记个日志并保持安静。

3. 下层的方法也可以选择无视这个异常（或者抓住并重扔出来）

想象下一直扔到main方法仍然没有处理这个异常。这种情况下，程序肯定会输出一个异常给console后退出。

你可以把同样的情况套用在线程上。如果一个子线程抛了异常而再假设run或*call方法没有处理它，那么这个异常就会期望放在父线程或主线程中解决，无论哪种情况，如果主线程没有处理他，系统就会退出。

让我们再看看 - 如果被context.actorof创建出来的子Actor因为一个异常失败了。父actor（指supervisor）可以处理子actor的任何失败。如果父actor做了，他可以处理并恢复（Restart/Resume）。另外，把异常传递（Escalate）给父actor。 还有一种做法，可以直接stop掉子actor - 这就是那个子actor结局了。 为什么我说父actor（那个supervisor）？这是因为akka的监护方式为家长监护 - 这意味着只有创建了actor的人才能监护他们。

就这么多了！我们已经覆盖到所有监护指令（Directoives）了。

策略

我忘了说一点： 你已经知道一个Akka Actor可以创建子actor并且子actor也可以随意创建他们自己的子actor。

现在，想下以下两个场景：

1.OneForOneStrategy

你的actor创建了很多子actor并且每一个子actor都连接了不同的数据源。假设你运行的是一个将英语翻译成多种语言的应用。

假设，一个子actor失败了然而你可以接受在最终结果里跳过这个结果，你想怎么做？关掉这个服务？当然不，你可能想要重启/关闭这个有问题的子actor。是吧？现在这个策略在Akka的监护策略中叫OneForOneStrategy策略 - 如果一个actor挂了，只单独处理这个actor。

基于你的业务异常，你可能需要对不同的异常有不同的反应（停止，重启，升级，恢复）。要配置你自己的策略，你只需要override你Actor类中的supervisorStrategy方法。

声明OneForOneStrategy的例子

import akka.actor.Actor  import akka.actor.ActorLogging  import akka.actor.OneForOneStrategy  import akka.actor.SupervisorStrategy.Stopclass TeacherActorOneForOne extends Actor with ActorLogging {    ...    ...  override val supervisorStrategy=OneForOneStrategy() {    case _: MinorRecoverableException     => Restart    case _: Exception                   => Stop  }  ...  ...  

2.AllForOneStrategy策略

假设你在做一个外部排序 (这是个又证明了我没啥创造力的例子！），你的每个块都被一个不同的actor处理。突然，一个Actor失败了并抛了一个异常。这样再往下处理就没什么意思了因为最终结果肯定是错的。所以，逻辑就是停止stop所有的actor。

我为什么说stop而不是重启？因为在这个例子里重启也没用，每个actor的mailbox在重启时并不会被清理。所以，如果我们重启了，另外的chunk仍然会被处理。这不是我们想要的。重建actor并用新的mailbox在这里是个更合适的策略。

与OneForOneStrategy一样，只需要用AllForOneStrategy的实现覆写supervisorStrategy

下面是例子

import akka.actor.{Actor, ActorLogging}  import akka.actor.AllForOneStrategy  import akka.actor.SupervisorStrategy.Escalate  import akka.actor.SupervisorStrategy.Stopclass TeacherActorAllForOne extends Actor with ActorLogging {  ...  override val supervisorStrategy = AllForOneStrategy() {    case _: MajorUnRecoverableException => Stop    case _: Exception => Escalate  }  ...  ...

指令 DIRECTIVES

AllForOneStrategy和OneForOneStrategy的构造方法都接受一个叫Decider的PartialFunction[Throwable,Directive]方法，他把Throwable与Directive指令做了一个映射：

case _: MajorUnRecoverableException => Stop  

这就简单的四个指令 - Stop，Resume，Escalate和Restart

Stop

在异常发生时子actor会停止，任何发给停止的actor的消息都会被转到deadLetter队列。

Resume

子actor会忽略抛出异常的消息并且继续处理队列中的其他消息。

Restart

子actor会停止并且一个新的actor会初始化。继续处理mailbox中其他的消息。世界对这个是无感知的因为同样的ActorRef指向了新的Actor。

Escalate

supervisor复制了失败并让他的supervisor处理这个异常。

缺省策略

如果我们的actor没指定任何策略但是创建了子actor。他们会怎样处理？Actor会有一个缺省的策略：

override val supervisorStrategy=OneForOneStrategy() {    case _: ActorInitializationException=> Stop    case _: ActorKilledException        => Stop    case _: DeathPactException             => Stop    case _: Exception                   => Restart}

所以，缺省策略处理了四个case：

1. ACTORINITIALIZATIONEXCEPTION => STOP

当actor不能初始化，他会抛出一个ActorInitializationException。actor会被停止。让我们在preStart调用中模拟下这个：

package me.rerun.akkanotes.supervisionimport akka.actor.{ActorSystem, Props}  import me.rerun.akkanotes.protocols.TeacherProtocol.QuoteRequest  import akka.actor.Actor  import akka.actor.ActorLoggingobject ActorInitializationExceptionApp extends App{  val actorSystem=ActorSystem("ActorInitializationException")  val actor=actorSystem.actorOf(Props[ActorInitializationExceptionActor], "initializationExceptionActor")  actor!"someMessageThatWillGoToDeadLetter"}class ActorInitializationExceptionActor extends Actor with ActorLogging{    override def preStart={    throw new Exception("Some random exception")  }  def receive={    case _=>  }}Ru

运行ActorInitializationExceptionApp会产生一个ActorInitializationException 异常然后所有的消息都会进deadLetterActor的消息队列：

Log

[ERROR] [11/10/2014 16:08:46.569] [ActorInitializationException-akka.actor.default-dispatcher-2] [akka://ActorInitializationException/user/initializationExceptionActor] Some random exceptionakka.actor.ActorInitializationException: exception during creation      at akka.actor.ActorInitializationException$.apply(Actor.scala:164)......Caused by: java.lang.Exception: Some random exception      at me.rerun.akkanotes.supervision.ActorInitializationExceptionActor.preStart(ActorInitializationExceptionApp.scala:17)......[INFO] [11/10/2014 16:08:46.581] [ActorInitializationException-akka.actor.default-dispatcher-4] [akka://ActorInitializationException/user/initializationExceptionActor] Message [java.lang.String] from Actor[akka://ActorInitializationException/deadLetters] to Actor[akka://ActorInitializationException/user/initializationExceptionActor# -1290470495] 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'.

2. ACTORKILLEDEXCEPTION => STOP

当Actor被kill消息关闭后，他会抛出一个ActorKilledException。如果抛这个异常，缺省策略会让子actor停止。看起来停止一个被kill掉的actor没什么意义。但想想这个：

1. ActorKilledException 会被传递给supervisor。 那么之前我们在DeathWatch里面提到的Actor里的生命周期watch或deathwatchers。 直到Actor被停掉前watcher不会知道任何事情。

2. 给Actor发送kill只会让那个特定的监管actor知道。用stop处理会暂停那个actor的mailbox，暂停了子actor的mailbox，停止了子actor，发送了Terminated给所有子actor的watcher，发送给所有类一个Terminated，然后actor的watcher都会迅速失败最终让Actor自己停止、

package me.rerun.akkanotes.supervisionimport akka.actor.{ActorSystem, Props}  import me.rerun.akkanotes.protocols.TeacherProtocol.QuoteRequest  import akka.actor.Actor  import akka.actor.ActorLogging  import akka.actor.Killobject ActorKilledExceptionApp extends App{  val actorSystem=ActorSystem("ActorKilledExceptionSystem")  val actor=actorSystem.actorOf(Props[ActorKilledExceptionActor])  actor!"something"  actor!Kill  actor!"something else that falls into dead letter queue"}class ActorKilledExceptionActor extends Actor with ActorLogging{    def receive={    case message:String=> log.info (message)  }}

Log

日志说只要ActorKilledException 进来，supervisor就会停掉actor并且消息会进入deadLetter队列

INFO  m.r.a.s.ActorKilledExceptionActor - somethingERROR akka.actor.OneForOneStrategy - Kill  akka.actor.ActorKilledException: KillINFO  akka.actor.RepointableActorRef - Message [java.lang.String] from Actor[akka://ActorKilledExceptionSystem/deadLetters] to Actor[akka://ActorKilledExceptionSystem/user/$a# -1569063462] 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'.

3. DEATHPACTEXCEPTION => STOP

在[DeathWatch]()文中，你可以看到当一个Actor观察一个子Actor时，他期望在他的receive中处理Terminated消息。如果没有呢？你会得到一个DeathPactException

代码演示了supervisorwatch子actor但没有从子actor处理Terminated消息。

package me.rerun.akkanotes.supervisionimport akka.actor.{ActorSystem, Props}  import me.rerun.akkanotes.protocols.TeacherProtocol.QuoteRequest  import akka.actor.Actor  import akka.actor.ActorLogging  import akka.actor.Kill  import akka.actor.PoisonPill  import akka.actor.Terminatedobject DeathPactExceptionApp extends App{  val actorSystem=ActorSystem("DeathPactExceptionSystem")  val actor=actorSystem.actorOf(Props[DeathPactExceptionParentActor])  actor!"create_child" //Throws DeathPactException  Thread.sleep(2000) //Wait until Stopped  actor!"someMessage" //Message goes to DeadLetters}class DeathPactExceptionParentActor extends Actor with ActorLogging{  def receive={    case "create_child"=> {      log.info ("creating child")      val child=context.actorOf(Props[DeathPactExceptionChildActor])      context.watch(child) //Watches but doesnt handle terminated message. Throwing DeathPactException here.      child!"stop"    }    case "someMessage" => log.info ("some message")    //Doesnt handle terminated message    //case Terminated(_) =>  }}class DeathPactExceptionChildActor extends Actor with ActorLogging{    def receive={    case "stop"=> {      log.info ("Actor going to stop and announce that it's terminated")      self!PoisonPill    }  }}

Log

日志告诉我们DeathPactException 进来了，supervisor停止了actor然后消息都进入了deadLetter的队列

INFO  m.r.a.s.DeathPactExceptionParentActor - creating childINFO  m.r.a.s.DeathPactExceptionChildActor - Actor going to stop and announce that it's terminatedERROR akka.actor.OneForOneStrategy - Monitored actor [Actor[akka://DeathPactExceptionSystem/user/$a/$a# -695506341]] terminated  akka.actor.DeathPactException: Monitored actor [Actor[akka://DeathPactExceptionSystem/user/$a/$a# -695506341]] terminatedINFO  akka.actor.RepointableActorRef - Message [java.lang.String] from Actor[akka://DeathPactExceptionSystem/deadLetters] to Actor[akka://DeathPactExceptionSystem/user/$a# -1452955980] 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'.

4. EXCEPTION => RESTART

对于其他的异常，缺省的指令是重启Actor。看下这个应用。只是要证明下Actor重启了，OtherExceptionParentActor让child抛出一个异常并立刻发送一条消息。消息在子actor重启的时候到达了mailbox，并被处理了。真不错！

package me.rerun.akkanotes.supervisionimport akka.actor.Actor  import akka.actor.ActorLogging  import akka.actor.ActorSystem  import akka.actor.OneForOneStrategy  import akka.actor.Props  import akka.actor.SupervisorStrategy.Stopobject OtherExceptionApp extends App{  val actorSystem=ActorSystem("OtherExceptionSystem")  val actor=actorSystem.actorOf(Props[OtherExceptionParentActor])  actor!"create_child"}class OtherExceptionParentActor extends Actor with ActorLogging{  def receive={    case "create_child"=> {      log.info ("creating child")      val child=context.actorOf(Props[OtherExceptionChildActor])      child!"throwSomeException"      child!"someMessage"    }  }}class OtherExceptionChildActor extends akka.actor.Actor with ActorLogging{  override def preStart={    log.info ("Starting Child Actor")  }  def receive={    case "throwSomeException"=> {      throw new Exception ("I'm getting thrown for no reason")     }    case "someMessage" => log.info ("Restarted and printing some Message")  }  override def postStop={    log.info ("Stopping Child Actor")  }}

Log

1.异常抛出了，我们能在trace中看到

1. 子类重启了 - stop和start被调用了（我们稍后能看到preRestart和postRestart）

2. 消息在重启开始前被发送给子actor。

INFO  m.r.a.s.OtherExceptionParentActor - creating childINFO  m.r.a.s.OtherExceptionChildActor - Starting Child ActorERROR akka.actor.OneForOneStrategy - I'm getting thrown for no reasonjava.lang.Exception: I'm getting thrown for no reason      at me.rerun.akkanotes.supervision.OtherExceptionChildActor$$anonfun$receive$2.applyOrElse(OtherExceptionApp.scala:39) ~[classes/:na]    at akka.actor.Actor$class.aroundReceive(Actor.scala:465) ~[akka-actor_2.11-2.3.4.jar:na]......    INFO  m.r.a.s.OtherExceptionChildActor - Stopping Child ActorINFO  m.r.a.s.OtherExceptionChildActor - Starting Child ActorINFO  m.r.a.s.OtherExceptionChildActor - Restarted and printing some Message

ESCALATE AND RESUME

我们在defaultStrategy中看到stop和restart的例子。现在让我们快速看下Escalate。

Resume忽略了异常并处理mailbox中的下条消息。这就像是抓住了异常但什么事也没做。

Escalating更像是异常是致命的而supervisor不能处理它。所以，他要向他的supervisor求救。让我们看个例子。

假设有三个Actor - EscalateExceptionTopLevelActor, EscalateExceptionParentActor 和 EscalateExceptionChildActor。 如果一个子actor抛出一个日常并且父级别actor不能处理它，他可以Escalate这个异常到顶级actor。顶级actor也可以选择对哪些指令做出响应。在我们的例子里，我们只是做了stop。stop会立即停掉child（这里是EscalateExceptionParentActor）。我们知道，当一个actor执行stop时，他的所有子类都会在actor自己停掉前先停止。

package me.rerun.akkanotes.supervisionimport akka.actor.Actor  import akka.actor.ActorLogging  import akka.actor.ActorSystem  import akka.actor.OneForOneStrategy  import akka.actor.Props  import akka.actor.SupervisorStrategy.Escalate  import akka.actor.SupervisorStrategy.Stop  import akka.actor.actorRef2Scalaobject EscalateExceptionApp extends App {  val actorSystem = ActorSystem("EscalateExceptionSystem")  val actor = actorSystem.actorOf(Props[EscalateExceptionTopLevelActor], "topLevelActor")  actor ! "create_parent"}class EscalateExceptionTopLevelActor extends Actor with ActorLogging {  override val supervisorStrategy = OneForOneStrategy() {    case _: Exception => {      log.info("The exception from the Child is now handled by the Top level Actor. Stopping Parent Actor and its children.")      Stop //Stop will stop the Actor that threw this Exception and all its children    }  }  def receive = {    case "create_parent" => {      log.info("creating parent")      val parent = context.actorOf(Props[EscalateExceptionParentActor], "parentActor")      parent ! "create_child" //Sending message to next level    }  }}class EscalateExceptionParentActor extends Actor with ActorLogging {  override def preStart={    log.info ("Parent Actor started")  }  override val supervisorStrategy = OneForOneStrategy() {    case _: Exception => {      log.info("The exception is ducked by the Parent Actor. Escalating to TopLevel Actor")      Escalate    }  }  def receive = {    case "create_child" => {      log.info("creating child")      val child = context.actorOf(Props[EscalateExceptionChildActor], "childActor")      child ! "throwSomeException"    }  }  override def postStop = {    log.info("Stopping parent Actor")  }}class EscalateExceptionChildActor extends akka.actor.Actor with ActorLogging {  override def preStart={    log.info ("Child Actor started")  }  def receive = {    case "throwSomeException" => {      throw new Exception("I'm getting thrown for no reason.")    }  }  override def postStop = {    log.info("Stopping child Actor")  }}

Log

可以在log中看到,

1. 子actor抛了异常。

2. supervisor（EscalateExceptionParentActor）升级了（escalate）异常抛给了他的supervisor（EscalateExceptionTopLevelActor）

3. EscalateExceptionTopLevelActor 的指令是关闭actor。在顺序上，子actor先停止。

4. 父actor之后再停止（在watcher被通知后）

INFO  m.r.a.s.EscalateExceptionTopLevelActor - creating parentINFO  m.r.a.s.EscalateExceptionParentActor - Parent Actor startedINFO  m.r.a.s.EscalateExceptionParentActor - creating childINFO  m.r.a.s.EscalateExceptionChildActor - Child Actor startedINFO  m.r.a.s.EscalateExceptionParentActor - The exception is ducked by the Parent Actor. Escalating to TopLevel ActorINFO  m.r.a.s.EscalateExceptionTopLevelActor - The exception from the Child is now handled by the Top level Actor. Stopping Parent Actor and its children.ERROR akka.actor.OneForOneStrategy - I'm getting thrown for no reason.  java.lang.Exception: I'm getting thrown for no reason.      at me.rerun.akkanotes.supervision.EscalateExceptionChildActor$$anonfun$receive$3.applyOrElse(EscalateExceptionApp.scala:71) ~[classes/:na]    ...    ...INFO  m.r.a.s.EscalateExceptionChildActor - Stopping child ActorINFO  m.r.a.s.EscalateExceptionParentActor - Stopping parent Actor

请记住无论哪个指令发出只会使用在被escalated的子类上。 例如，一个restart指令从顶层发出，只有父类会被重启并且在构造函数中/preStart中的都会被执行。如果一个父actor的子类在构造函数中呗创建，他们就会被创建。然而，在消息中创建的child的父actor仍然会在Terminated状态。

TRIVIA

实际上，你可以控制是否preStart被调用。我们可以在下节看到。如果你好奇，可以看下Actor中的*postRestart方法

def postRestart(reason: Throwable): Unit = {    preStart()}

代码

跟往常一样，代码在github

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

关键字：akka

版权声明

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处。如若内容有涉嫌抄袭侵权/违法违规/事实不符，请点击 举报 进行投诉反馈！