Actor 生命周期

依赖

为了使用 Akka Actor 类型，你需要将以下依赖添加到你的项目中：

1. <!-- Maven -->
2. <dependency>
3. <groupId>com.typesafe.akka</groupId>
4. <artifactId>akka-actor-typed_2.12</artifactId>
5. <version>2.5.23</version>
6. </dependency>

8. <!-- Gradle -->
9. dependencies {
10. compile group: 'com.typesafe.akka', name: 'akka-actor-typed_2.12', version: '2.5.23'
11. }

13. <!-- sbt -->
14. libraryDependencies += "com.typesafe.akka" %% "akka-actor-typed" % "2.5.23"

创建 Actors

一个 Actor 可以创建或生成任意数量的子 Actor，而子 Actor 又可以生成自己的子 Actor，从而形成一个 Actor 层次。「ActorSystem」承载层次结构，并且在ActorSystem层次结构的顶部只能有一个根 Actor。一个子 Actor 的生命周期是与其父 Actor 联系在一起的，一个子 Actor 可以在任何时候停止自己或被停止，但永远不能比父 Actor 活得更久。

守护者 Actor

根 Actor，也称为守护者 Actor，与ActorSystem一起创建。发送到 Actor 系统的消息被定向到根 Actor。根 Actor 是由用于创建ActorSystem的行为定义的，在下面的示例中名为HelloWorldMain.main：

1. final ActorSystem<HelloWorldMain.Start> system =
2. ActorSystem.create(HelloWorldMain.main, "hello");

4. system.tell(new HelloWorldMain.Start("World"));
5. system.tell(new HelloWorldMain.Start("Akka"));

繁衍子级

子 Actor 是由「ActorContext」的“繁殖”产生的。在下面的示例中，当根 Actor 启动时，它生成一个由行为HelloWorld.greeter描述的子 Actor。此外，当根 Actor 收到Start消息时，它将创建由行为HelloWorldBot.bot定义的子 Actor：

1. public abstract static class HelloWorldMain {
2. private HelloWorldMain() {}

4. public static class Start {
5. public final String name;

7. public Start(String name) {
8. this.name = name;
9. }
10. }

12. public static final Behavior<Start> main =
13. Behaviors.setup(
14. context -> {
15. final ActorRef<HelloWorld.Greet> greeter =
16. context.spawn(HelloWorld.greeter, "greeter");

18. return Behaviors.receiveMessage(
19. message -> {
20. ActorRef<HelloWorld.Greeted> replyTo =
21. context.spawn(HelloWorldBot.bot(0, 3), message.name);
22. greeter.tell(new HelloWorld.Greet(message.name, replyTo));
23. return Behaviors.same();
24. });
25. });
26. }

要在生成 Actor 时指定调度器，请使用「DispatcherSelector」。如果未指定，则 Actor 将使用默认调度器，有关详细信息，请参阅「默认调度器」。

1. public static final Behavior<Start> main =
2. Behaviors.setup(
3. context -> {
4. final String dispatcherPath = "akka.actor.default-blocking-io-dispatcher";

6. Props props = DispatcherSelector.fromConfig(dispatcherPath);
7. final ActorRef<HelloWorld.Greet> greeter =
8. context.spawn(HelloWorld.greeter, "greeter", props);

10. return Behaviors.receiveMessage(
11. message -> {
12. ActorRef<HelloWorld.Greeted> replyTo =
13. context.spawn(HelloWorldBot.bot(0, 3), message.name);
14. greeter.tell(new HelloWorld.Greet(message.name, replyTo));
15. return Behaviors.same();
16. });
17. });

通过参阅「Actors」，以了解上述示例。

SpawnProtocol

守护者 Actor 应该负责初始化任务并创建应用程序的初始 Actor，但有时你可能希望从守护者 Actor 的外部生成新的 Actor。例如，每个 HTTP 请求创建一个 Actor。

这并不难你在行为中的实现，但是由于这是一个常见的模式，因此有一个预定义的消息协议和行为的实现。它可以用作ActorSystem的守护者 Actor，可能与Behaviors.setup结合使用以启动一些初始任务或 Actor。然后，可以通过调用SpawnProtocol.Spawn从外部启动子 Actor，生成到系统的 Actor 引用。使用ask时，这类似于ActorSystem.actorOf如何在非类型化 Actor 中使用，不同之处在于ActorRef的CompletionStage返回。

守护者行为可定义为：

1. import akka.actor.typed.Behavior;
2. import akka.actor.typed.SpawnProtocol;
3. import akka.actor.typed.javadsl.Behaviors;

5. public abstract static class HelloWorldMain {
6. private HelloWorldMain() {}

8. public static final Behavior<SpawnProtocol> main =
9. Behaviors.setup(
10. context -> {
11. // Start initial tasks
12. // context.spawn(...)

14. return SpawnProtocol.behavior();
15. });
16. }

而ActorSystem可以用这种main行为来创建，并生成其他 Actor：

1. import akka.actor.typed.ActorRef;
2. import akka.actor.typed.ActorSystem;
3. import akka.actor.typed.Props;
4. import akka.actor.typed.javadsl.AskPattern;
5. import akka.util.Timeout;

7. final ActorSystem<SpawnProtocol> system = ActorSystem.create(HelloWorldMain.main, "hello");
8. final Duration timeout = Duration.ofSeconds(3);

10. CompletionStage<ActorRef<HelloWorld.Greet>> greeter =
11. AskPattern.ask(
12. system,
13. replyTo ->
14. new SpawnProtocol.Spawn<>(HelloWorld.greeter, "greeter", Props.empty(), replyTo),
15. timeout,
16. system.scheduler());

18. Behavior<HelloWorld.Greeted> greetedBehavior =
19. Behaviors.receive(
20. (context, message) -> {
21. context.getLog().info("Greeting for {} from {}", message.whom, message.from);
22. return Behaviors.stopped();
23. });

25. CompletionStage<ActorRef<HelloWorld.Greeted>> greetedReplyTo =
26. AskPattern.ask(
27. system,
28. replyTo -> new SpawnProtocol.Spawn<>(greetedBehavior, "", Props.empty(), replyTo),
29. timeout,
30. system.scheduler());

32. greeter.whenComplete(
33. (greeterRef, exc) -> {
34. if (exc == null) {
35. greetedReplyTo.whenComplete(
36. (greetedReplyToRef, exc2) -> {
37. if (exc2 == null) {
38. greeterRef.tell(new HelloWorld.Greet("Akka", greetedReplyToRef));
39. }
40. });
41. }
42. });

还可以在 Actor 层次结构的其他位置使用SpawnProtocol。它不必是根守护者 Actor。

停止 Actors

Actor 可以通过返回Behaviors.stopped作为下一个行为来停止自己。

通过使用父 Actor 的ActorContext的stop方法，在子 Actor 完成当前消息的处理后，可以强制停止子 Actor。只有子 Actor 才能这样被阻止。

子 Actor 将作为父级关闭过程的一部分被停止。

停止 Actor 产生的PostStop信号可用于清除资源。请注意，可以选择将处理此类PostStop信号的行为定义为Behaviors.stopped的参数。如果 Actor 在突然停止时能优雅地停止自己，则需要不同的操作。

下面是一个示例：

1. import java.util.concurrent.TimeUnit;

3. import akka.actor.typed.ActorSystem;
4. import akka.actor.typed.Behavior;
5. import akka.actor.typed.PostStop;
6. import akka.actor.typed.javadsl.Behaviors;

9. public abstract static class JobControl {
10. // no instances of this class, it's only a name space for messages
11. // and static methods
12. private JobControl() {}

14. static interface JobControlLanguage {}

16. public static final class SpawnJob implements JobControlLanguage {
17. public final String name;

19. public SpawnJob(String name) {
20. this.name = name;
21. }
22. }

24. public static final class GracefulShutdown implements JobControlLanguage {

26. public GracefulShutdown() {}
27. }

29. public static final Behavior<JobControlLanguage> mcpa =
30. Behaviors.receive(JobControlLanguage.class)
31. .onMessage(
32. SpawnJob.class,
33. (context, message) -> {
34. context.getSystem().log().info("Spawning job {}!", message.name);
35. context.spawn(Job.job(message.name), message.name);
36. return Behaviors.same();
37. })
38. .onSignal(
39. PostStop.class,
40. (context, signal) -> {
41. context.getSystem().log().info("Master Control Programme stopped");
42. return Behaviors.same();
43. })
44. .onMessage(
45. GracefulShutdown.class,
46. (context, message) -> {
47. context.getSystem().log().info("Initiating graceful shutdown...");

49. // perform graceful stop, executing cleanup before final system termination
50. // behavior executing cleanup is passed as a parameter to Actor.stopped
51. return Behaviors.stopped(
52. () -> {
53. context.getSystem().log().info("Cleanup!");
54. });
55. })
56. .onSignal(
57. PostStop.class,
58. (context, signal) -> {
59. context.getSystem().log().info("Master Control Programme stopped");
60. return Behaviors.same();
61. })
62. .build();
63. }

65. public static class Job {
66. public static Behavior<JobControl.JobControlLanguage> job(String name) {
67. return Behaviors.receiveSignal(
68. (context, PostStop) -> {
69. context.getSystem().log().info("Worker {} stopped", name);
70. return Behaviors.same();
71. });
72. }
73. }

75. final ActorSystem<JobControl.JobControlLanguage> system =
76. ActorSystem.create(JobControl.mcpa, "B6700");

78. system.tell(new JobControl.SpawnJob("a"));
79. system.tell(new JobControl.SpawnJob("b"));

81. // sleep here to allow time for the new actors to be started
82. Thread.sleep(100);

84. system.tell(new JobControl.GracefulShutdown());

86. system.getWhenTerminated().toCompletableFuture().get(3, TimeUnit.SECONDS);

英文原文链接：Actor lifecycle.