容错

当 Actor 在处理消息或初始化过程中抛出非预期的异常、失败时，默认情况下，Actor 将停止。

  • 注释：类型化 Actor 和非类型化 Actor 之间的一个重要区别是，如果抛出异常，并且在创建 Actor 时未定义监督策略，则类型化 Actor 将会停止，而非类型化 Actor 则会重启。

请注意，失败和验证错误之间有一个重要区别：

  • 验证错误意味着发送给 Actor 的命令是无效的，这应该作为 Actor 协议的一部分建模，而不是使 Actor 抛出异常。
  • 相反，失败是一些意外的事情，或者是 Actor 本身无法控制的事情，例如断开的数据库连接。与验证错误相反，将协议的某些部分建模为发送 Actor 没有太大的作用。
  • 对于失败，应用“让它崩溃”的理念是很有用的：我们将责任转移到其他地方，而不是混合细粒度恢复和内部状态的更正，这些内部状态可能由于失败而部分无效。在许多情况下，解决方法可以是销毁 Actor，然后用我们知道有效的新状态创建一个新的 Actor。

监督

在 Akka 类型中，这个“其他地方”被称为监督（In Akka Typed this “somewhere else” is called supervision）。监督允许你声明性地描述在 Actor 内部抛出某种类型的异常时应该发生什么。要使用监督，实际的 Actor 行为将使用Behaviors.supervise进行包装，例如重新启动IllegalStateExceptions：

  1. Behaviors.supervise(behavior)
  2.     .onFailure(IllegalStateException.class, SupervisorStrategy.restart());

或者，要继续，请忽略失败并处理下一条消息，而不是：

  1. Behaviors.supervise(behavior)
  2.     .onFailure(IllegalStateException.class, SupervisorStrategy.resume());

可以使用更复杂的重启策略，例如，在 10 秒钟内重启不超过 10 次：

  1. Behaviors.supervise(behavior)
  2.     .onFailure(
  3.         IllegalStateException.class,
  4.         SupervisorStrategy.restart().withLimit(10, FiniteDuration.apply(10, TimeUnit.SECONDS)));

要使用不同的策略处理不同的异常，可以嵌套调用supervise方法：

  1. Behaviors.supervise(
  2.         Behaviors.supervise(behavior)
  3.             .onFailure(IllegalStateException.class, SupervisorStrategy.restart()))
  4.     .onFailure(IllegalArgumentException.class, SupervisorStrategy.stop());

有关策略的完整列表，请参阅有关SupervisorStrategy的公共方法。

包装行为

通过改变行为（behavior）来存储状态是很常见的，例如

  1. interface CounterMessage {}
  3. public static final class Increase implements CounterMessage {}
  5. public static final class Get implements CounterMessage {
  6.   final ActorRef<Got> sender;
  8.   public Get(ActorRef<Got> sender) {
  9.     this.sender = sender;
  10.   }
  11. }
  13. public static final class Got {
  14.   final int n;
  16.   public Got(int n) {
  17.     this.n = n;
  18.   }
  19. }
  21. public static Behavior<CounterMessage> counter(int currentValue) {
  22.   return Behaviors.receive(CounterMessage.class)
  23.       .onMessage(
  24.           Increase.class,
  25.           (context, o) -> {
  26.             return counter(currentValue + 1);
  27.           })
  28.       .onMessage(
  29.           Get.class,
  30.           (context, o) -> {
  31.             o.sender.tell(new Got(currentValue));
  32.             return Behaviors.same();
  33.           })
  34.       .build();
  35. }

进行此项监督时，只需将其添加到顶层：

  1. Behaviors.supervise(counter(1));

每个返回的行为都将自动与监督者重新包装。

当父级正在重新启动时，子 Actor 将停止

子 Actor 通常在重新启动父 Actor 时运行的setup块中启动。每次重新启动父 Actor 时，都会停止子 Actor，以避免资源泄漏，从而创建新的子 Actor。

  1. static Behavior<String> child(long size) {
  2.   return Behaviors.receiveMessage(msg -> child(size + msg.length()));
  3. }
  5. static Behavior<String> parent() {
  6.   return Behaviors.<String>supervise(
  7.           Behaviors.setup(
  8.               ctx -> {
  9.                 final ActorRef<String> child1 = ctx.spawn(child(0), "child1");
  10.                 final ActorRef<String> child2 = ctx.spawn(child(0), "child2");
  12.                 return Behaviors.receiveMessage(
  13.                     msg -> {
  14.                       // there might be bugs here...
  15.                       String[] parts = msg.split(" ");
  16.                       child1.tell(parts[0]);
  17.                       child2.tell(parts[1]);
  18.                       return Behaviors.same();
  19.                     });
  20.               }))
  21.       .onFailure(SupervisorStrategy.restart());
  22. }

可以重写此项，以便在重新启动父 Actor 时不影响子 Actor。然后，重新启动的父实例将具有与失败前相同的子实例。

如果子 Actor 是从setup创建的，如前一个示例中所示，并且在重新启动父 Actor 时它们应该保持完整（不停止），则应将supervise放置在setup中，并使用SupervisorStrategy.restart().withStopChildren(false)，如下所示：

  1. static Behavior<String> parent2() {
  2.   return Behaviors.setup(
  3.       ctx -> {
  4.         final ActorRef<String> child1 = ctx.spawn(child(0), "child1");
  5.         final ActorRef<String> child2 = ctx.spawn(child(0), "child2");
  7.         // supervision strategy inside the setup to not recreate children on restart
  8.         return Behaviors.<String>supervise(
  9.                 Behaviors.receiveMessage(
  10.                     msg -> {
  11.                       // there might be bugs here...
  12.                       String[] parts = msg.split(" ");
  13.                       child1.tell(parts[0]);
  14.                       child2.tell(parts[1]);
  15.                       return Behaviors.same();
  16.                     }))
  17.             .onFailure(SupervisorStrategy.restart().withStopChildren(false));
  18.       });
  19. }

这意味着setup块只在父 Actor 第一次启动时运行，而不是在重新启动时运行。

失败在整个层次结构中冒泡

在某些情况下，在 Actor 层次结构中向上推送关于如何处理失败的决策，并让父 Actor 处理失败（在非类型化的 Akka Actor 中，这是默认的工作方式）可能很有用。

当一个子 Actor 被终止时，父 Actor 要得到通知，就必须watch这个子 Actor。如果由于故障而停止子进程，则将收到包含原因的ChildFailed信号。ChildFailed扩展了Terminated，因此如果你的用例不需要区分停止和失败，你可以使用Terminated信号来处理这两个用例。

如果父级反过来不处理Terminated消息，那么它本身将失败，并抛出akka.actor.typed.DeathPactException。

在某些情况下，如果希望原始异常在层次结构中冒泡，可以通过处理Terminated信号并在每个 Actor 中重新抛出异常来完成。

  1. public class BubblingSample {
  2.   interface Message {}
  4.   public static class Fail implements Message {
  5.     public final String text;
  7.     public Fail(String text) {
  8.       this.text = text;
  9.     }
  10.   }
  12.   public static Behavior<Message> failingChildBehavior =
  13.       Behaviors.receive(Message.class)
  14.           .onMessage(
  15.               Fail.class,
  16.               (context, message) -> {
  17.                 throw new RuntimeException(message.text);
  18.               })
  19.           .build();
  21.   public static Behavior<Message> middleManagementBehavior =
  22.       Behaviors.setup(
  23.           (context) -> {
  24.             context.getLog().info("Middle management starting up");
  25.             final ActorRef<Message> child = context.spawn(failingChildBehavior, "child");
  26.             // we want to know when the child terminates, but since we do not handle
  27.             // the Terminated signal, we will in turn fail on child termination
  28.             context.watch(child);
  30.             // here we don't handle Terminated at all which means that
  31.             // when the child fails or stops gracefully this actor will
  32.             // fail with a DeathWatchException
  33.             return Behaviors.receive(Message.class)
  34.                 .onMessage(
  35.                     Message.class,
  36.                     (innerCtx, message) -> {
  37.                       // just pass messages on to the child
  38.                       child.tell(message);
  39.                       return Behaviors.same();
  40.                     })
  41.                 .build();
  42.           });
  44.   public static Behavior<Message> bossBehavior =
  45.       Behaviors.setup(
  46.           (context) -> {
  47.             context.getLog().info("Boss starting up");
  48.             final ActorRef<Message> middleManagement =
  49.                 context.spawn(middleManagementBehavior, "middle-management");
  50.             context.watch(middleManagement);
  52.             // here we don't handle Terminated at all which means that
  53.             // when middle management fails with a DeathWatchException
  54.             // this actor will also fail
  55.             return Behaviors.receive(Message.class)
  56.                 .onMessage(
  57.                     Message.class,
  58.                     (innerCtx, message) -> {
  59.                       // just pass messages on to the child
  60.                       middleManagement.tell(message);
  61.                       return Behaviors.same();
  62.                     })
  63.                 .build();
  64.           });
  66.   public static void main(String[] args) {
  67.     final ActorSystem<Message> system = ActorSystem.create(bossBehavior, "boss");
  69.     system.tell(new Fail("boom"));
  70.     // this will now bubble up all the way to the boss and as that is the user guardian it means
  71.     // the entire actor system will stop
  72.   }
  73. }

英文原文链接：Fault Tolerance.