11. Program at a Higher Level
• Never think in terms of shared state, state
visibility, threads, locks, concurrent collections,
thread notifications etc.
高レベルプログラミング
12. Program at a Higher Level
• Never think in terms of shared state, state
visibility, threads, locks, concurrent collections,
thread notifications etc.
• Low level concurrency plumbing BECOMES
SIMPLE WORKFLOW - you only think about how
messages flow in the system
高レベルプログラミング
13. Program at a Higher Level
• Never think in terms of shared state, state
visibility, threads, locks, concurrent collections,
thread notifications etc.
• Low level concurrency plumbing BECOMES
SIMPLE WORKFLOW - you only think about how
messages flow in the system
• You get high CPU utilization, low latency, high
throughput and scalability - FOR FREE as part of
the model
高レベルプログラミング
14. Program at a Higher Level
• Never think in terms of shared state, state
visibility, threads, locks, concurrent collections,
thread notifications etc.
• Low level concurrency plumbing BECOMES
SIMPLE WORKFLOW - you only think about how
messages flow in the system
• You get high CPU utilization, low latency, high
throughput and scalability - FOR FREE as part of
the model
• Proven and superior model for detecting and
recovering from errors
高レベルプログラミング
18. Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
生まれながらに分散化されている
19. Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
生まれながらに分散化されている
20. Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
- elastic & dynamic
生まれながらに分散化されている
21. Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
- elastic & dynamic
- fault-tolerant & self-healing
生まれながらに分散化されている
22. Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
- elastic & dynamic
- fault-tolerant & self-healing
- adaptive load-balancing, cluster rebalancing & actor migration
生まれながらに分散化されている
23. Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
- elastic & dynamic
- fault-tolerant & self-healing
- adaptive load-balancing, cluster rebalancing & actor migration
- build extremely loosely coupled and dynamic systems that can
change and adapt at runtime
生まれながらに分散化されている
27. What is an Actor?
コードを分割して、並行性、スケーラビリティ、
耐障害性の高いアプリケーションを支援する
28. What is an Actor?
• Akka's unit of code organization is called an Actor
コードを分割して、並行性、スケーラビリティ、
耐障害性の高いアプリケーションを支援する
29. What is an Actor?
• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and
fault-tolerant applications
コードを分割して、並行性、スケーラビリティ、
耐障害性の高いアプリケーションを支援する
30. What is an Actor?
• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and
fault-tolerant applications
• Like Java EE servlets and session beans, Actors is a
model for organizing your code that keeps many
“policy decisions” separate from the business logic
コードを分割して、並行性、スケーラビリティ、
耐障害性の高いアプリケーションを支援する
31. What is an Actor?
• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and
fault-tolerant applications
• Like Java EE servlets and session beans, Actors is a
model for organizing your code that keeps many
“policy decisions” separate from the business logic
• Actors may be new to many in the Java community,
but they are a tried-and-true concept (Hewitt 1973)
used for many years in telecom systems with 9 nines
uptime
コードを分割して、並行性、スケーラビリティ、
耐障害性の高いアプリケーションを支援する
32. What can I use Actors for?
スレッド、コンポーネント、コールバックなどの代替
33. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
スレッド、コンポーネント、コールバックなどの代替
34. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
スレッド、コンポーネント、コールバックなどの代替
35. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
スレッド、コンポーネント、コールバックなどの代替
36. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
- a callback or listener
スレッド、コンポーネント、コールバックなどの代替
37. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
- a callback or listener
- a singleton or service
スレッド、コンポーネント、コールバックなどの代替
38. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
- a callback or listener
- a singleton or service
- a router, load-balancer or pool
スレッド、コンポーネント、コールバックなどの代替
39. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
- a callback or listener
- a singleton or service
- a router, load-balancer or pool
- a Java EE Session Bean or Message-Driven Bean
スレッド、コンポーネント、コールバックなどの代替
40. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
- a callback or listener
- a singleton or service
- a router, load-balancer or pool
- a Java EE Session Bean or Message-Driven Bean
- an out-of-process service
スレッド、コンポーネント、コールバックなどの代替
41. What can I use Actors for?
In different scenarios, an Actor may be an
alternative to:
- a thread
- an object instance or component
- a callback or listener
- a singleton or service
- a router, load-balancer or pool
- a Java EE Session Bean or Message-Driven Bean
- an out-of-process service
- a Finite State Machine (FSM)
スレッド、コンポーネント、コールバックなどの代替
43. Carl Hewitt’s definition
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
44. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
45. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
46. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
- Storage
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
47. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
48. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
- 3 axioms - When an Actor receives a message it can:
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
49. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
- 3 axioms - When an Actor receives a message it can:
- Create new Actors
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
50. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
- 3 axioms - When an Actor receives a message it can:
- Create new Actors
- Send messages to Actors it knows
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
51. Carl Hewitt’s definition
- The fundamental unit of computation that embodies:
- Processing
- Storage
- Communication
- 3 axioms - When an Actor receives a message it can:
- Create new Actors
- Send messages to Actors it knows
- Designate how it should handle the next message it receives
http://bit.ly/hewitt-on-actors
処理、記憶、通信を行う基礎単位。受信時の 3公理:
新規作成、他のアクターとの通信、次のメッセージ処理の指定
52. 4 core Actor operations
0. DEFINE
1. CREATE
2. SEND
3. BECOME
4. SUPERVISE
アクターの4つの主な仕事
53. 0. DEFINE
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
処理可能なメッセージ、振る舞いの定義
54. 0. DEFINE
Define the message(s) the Actor
should be able to respond to
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
処理可能なメッセージ、振る舞いの定義
55. 0. DEFINE
Define the message(s) the Actor
should be able to respond to
Define the Actor class
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
処理可能なメッセージ、振る舞いの定義
56. 0. DEFINE
Define the message(s) the Actor
should be able to respond to
Define the Actor class
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
Define the Actor’s behavior
処理可能なメッセージ、振る舞いの定義
57. 1. CREATE
• CREATE - creates a new instance of an Actor
• Extremely lightweight (2.7 Million per Gb RAM)
• Very strong encapsulation - encapsulates:
- state
- behavior
- message queue
• State & behavior is indistinguishable from each other
• Only way to observe state is by sending an actor a
message and see how it reacts
新規アクターの作成。強力なカプセル化。
メッセージを送ってその反応を見て状態を観測する。
58. CREATE Actor
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
ActorRef が返ってくる
59. CREATE Actor
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) Create an Actor system " + who)
=> log.info("Hello
}
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
ActorRef が返ってくる
60. CREATE Actor
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) Create an Actor system " + who)
=> log.info("Hello
}
Actor configuration
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
ActorRef が返ってくる
61. CREATE Actor
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) Create an Actor system " + who)
=> log.info("Hello
}
Actor configuration
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
Give it a name
ActorRef が返ってくる
62. CREATE Actor
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) Create an Actor system " + who)
=> log.info("Hello
}
Actor configuration
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
Create the Actor Give it a name
ActorRef が返ってくる
63. CREATE Actor
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) Create an Actor system " + who)
=> log.info("Hello
}
Actor configuration
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
Create the Actor
You get an ActorRef back Give it a name
ActorRef が返ってくる
64. Actors can form hierarchies
Guardian System Actor
階層構造を作ることができる
65. Actors can form hierarchies
Guardian System Actor
system.actorOf(Props[Foo], “Foo”)
階層構造を作ることができる
66. Actors can form hierarchies
Guardian System Actor
Foo system.actorOf(Props[Foo], “Foo”)
階層構造を作ることができる
67. Actors can form hierarchies
Guardian System Actor
Foo
context.actorOf(Props[A], “A”)
階層構造を作ることができる
68. Actors can form hierarchies
Guardian System Actor
Foo
A context.actorOf(Props[A], “A”)
階層構造を作ることができる
69. Actors can form hierarchies
Guardian System Actor
Foo Bar
A
A C
E C
B
B
D
階層構造を作ることができる
70. Name resolution - like a file-system
Guardian System Actor
Foo Bar
A
A C
E C
B
B
D
ファイルシステムのような名前解決
71. Name resolution - like a file-system
Guardian System Actor
/Foo
Foo Bar
A
A C
E C
B
B
D
ファイルシステムのような名前解決
72. Name resolution - like a file-system
Guardian System Actor
/Foo
Foo Bar
/Foo/A
A
A C
E C
B
B
D
ファイルシステムのような名前解決
73. Name resolution - like a file-system
Guardian System Actor
/Foo
Foo Bar
/Foo/A
A
A C
/Foo/A/B
E C
B
B
D
ファイルシステムのような名前解決
74. Name resolution - like a file-system
Guardian System Actor
/Foo
Foo Bar
/Foo/A
A
A C
/Foo/A/B
E C
B
B
D
/Foo/A/D
ファイルシステムのような名前解決
76. 2. SEND
• SEND - sends a message to an Actor
非同期でノンブロッキングなメッセージの送信
77. 2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
非同期でノンブロッキングなメッセージの送信
78. 2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• EVERYTHING is asynchronous and lockless
非同期でノンブロッキングなメッセージの送信
79. 2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• EVERYTHING is asynchronous and lockless
• Everything happens Reactively
非同期でノンブロッキングなメッセージの送信
80. 2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• EVERYTHING is asynchronous and lockless
• Everything happens Reactively
- An Actor is passive until a message is sent to it, which
triggers something within the Actor
非同期でノンブロッキングなメッセージの送信
81. 2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• EVERYTHING is asynchronous and lockless
• Everything happens Reactively
- An Actor is passive until a message is sent to it, which
triggers something within the Actor
- Messages is the Kinetic Energy in an Actor system
非同期でノンブロッキングなメッセージの送信
82. 2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• EVERYTHING is asynchronous and lockless
• Everything happens Reactively
- An Actor is passive until a message is sent to it, which
triggers something within the Actor
- Messages is the Kinetic Energy in an Actor system
- Actors can have lots of buffered Potential Energy but can't
do anything with it until it is triggered by a message
非同期でノンブロッキングなメッセージの送信
83. SEND message
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
greeter ! Greeting("Charlie Parker")
84. SEND message
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
greeter ! Greeting("Charlie Parker")
Send the message
85. Full example
case class Greeting(who: String)
class GreetingActor extends Actor with ActorLogging {
def receive = {
case Greeting(who) => log.info("Hello " + who)
}
}
val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
greeter ! Greeting("Charlie Parker")
93. 3. BECOME
• BECOME - dynamically redefines Actor’s behavior
動的にアクターの振る舞いを再定義
振る舞いはスタックして push/pop することができる
94. 3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
動的にアクターの振る舞いを再定義
振る舞いはスタックして push/pop することができる
95. 3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
• In a type system analogy it is as if the object changed
type - changed interface, protocol & implementation
動的にアクターの振る舞いを再定義
振る舞いはスタックして push/pop することができる
96. 3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
• In a type system analogy it is as if the object changed
type - changed interface, protocol & implementation
• Will now react differently to the messages it receives
動的にアクターの振る舞いを再定義
振る舞いはスタックして push/pop することができる
97. 3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
• In a type system analogy it is as if the object changed
type - changed interface, protocol & implementation
• Will now react differently to the messages it receives
• Behaviors are stacked & can be pushed and popped
動的にアクターの振る舞いを再定義
振る舞いはスタックして push/pop することができる
98. Why would I want to do that?
例) 輻輳時にアクターをルータへ変身、FSM の実装など
99. Why would I want to do that?
• Let a highly contended Actor adaptively transform itself into
an Actor Pool or a Router
例) 輻輳時にアクターをルータへ変身、FSM の実装など
100. Why would I want to do that?
• Let a highly contended Actor adaptively transform itself into
an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
例) 輻輳時にアクターをルータへ変身、FSM の実装など
101. Why would I want to do that?
• Let a highly contended Actor adaptively transform itself into
an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
例) 輻輳時にアクターをルータへ変身、FSM の実装など
102. Why would I want to do that?
• Let a highly contended Actor adaptively transform itself into
an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
• Spawn up (empty) generic Worker processes that can
become whatever the Master currently needs
例) 輻輳時にアクターをルータへ変身、FSM の実装など
103. Why would I want to do that?
• Let a highly contended Actor adaptively transform itself into
an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
• Spawn up (empty) generic Worker processes that can
become whatever the Master currently needs
• Other: Use your imagination!
例) 輻輳時にアクターをルータへ変身、FSM の実装など
104. Why would I want to do that?
• Let a highly contended Actor adaptively transform itself into
an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
• Spawn up (empty) generic Worker processes that can
become whatever the Master currently needs
• Other: Use your imagination!
• Very useful once you get the used to it
例) 輻輳時にアクターをルータへ変身、FSM の実装など
107. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
従来のリカバリはスレッドを用いたもの
108. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
従来のリカバリはスレッドを用いたもの
109. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
• So you need to do all explicit error handling WITHIN this
single thread
従来のリカバリはスレッドを用いたもの
110. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
• So you need to do all explicit error handling WITHIN this
single thread
• To make things worse - errors do not propagate between
threads so there is NO WAY OF EVEN FINDING OUT that
something have failed
従来のリカバリはスレッドを用いたもの
111. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
• So you need to do all explicit error handling WITHIN this
single thread
• To make things worse - errors do not propagate between
threads so there is NO WAY OF EVEN FINDING OUT that
something have failed
• This leads to DEFENSIVE programming with:
従来のリカバリはスレッドを用いたもの
112. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
• So you need to do all explicit error handling WITHIN this
single thread
• To make things worse - errors do not propagate between
threads so there is NO WAY OF EVEN FINDING OUT that
something have failed
• This leads to DEFENSIVE programming with:
• Error handling TANGLED with business logic
従来のリカバリはスレッドを用いたもの
113. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
• So you need to do all explicit error handling WITHIN this
single thread
• To make things worse - errors do not propagate between
threads so there is NO WAY OF EVEN FINDING OUT that
something have failed
• This leads to DEFENSIVE programming with:
• Error handling TANGLED with business logic
• SCATTERED all over the code base
従来のリカバリはスレッドを用いたもの
114. Failure Recovery in Java/C/C# etc.
• You are given a SINGLE thread of control
• If this thread blows up you are screwed
• So you need to do all explicit error handling WITHIN this
single thread
• To make things worse - errors do not propagate between
threads so there is NO WAY OF EVEN FINDING OUT that
something have failed
• This leads to DEFENSIVE programming with:
• Error handling TANGLED with business logic
• SCATTERED all over the code base
We can do better than this!!!
従来のリカバリはスレッドを用いたもの
119. 4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
• Error handling in actors is handle by letting Actors
monitor (supervise) each other for failure
アクターの故障時は上司の Supervisor が通知され、
対応する。通常処理とエラー処理が分離できる。
120. 4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
• Error handling in actors is handle by letting Actors
monitor (supervise) each other for failure
• This means that if an Actor crashes, a notification
will be sent to his supervisor, who can react upon
the failure
アクターの故障時は上司の Supervisor が通知され、
対応する。通常処理とエラー処理が分離できる。
121. 4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
• Error handling in actors is handle by letting Actors
monitor (supervise) each other for failure
• This means that if an Actor crashes, a notification
will be sent to his supervisor, who can react upon
the failure
• This provides clean separation of processing and
error handling
アクターの故障時は上司の Supervisor が通知され、
対応する。通常処理とエラー処理が分離できる。
130. SUPERVISE Actor
Every single actor has a
default supervisor strategy.
Which is usually sufficient.
But it can be overridden.
デフォルトの Supervisor 戦略をオーバーライドできる
131. SUPERVISE Actor
Every single actor has a
default supervisor strategy.
Which is usually sufficient.
But it can be overridden.
class Supervisor extends Actor {
override val supervisorStrategy =
(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
case _: ArithmeticException => Resume
case _: NullPointerException => Restart
case _: Exception => Escalate
}
デフォルトの=Supervisor 戦略をオーバーライドできる
val worker context.actorOf(Props[Worker])
132. SUPERVISE Actor
class Supervisor extends Actor {
override val supervisorStrategy =
(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
case _: ArithmeticException => Resume
case _: NullPointerException => Restart
case _: Exception => Escalate
}
val worker = context.actorOf(Props[Worker])
def receive = {
case n: Int => worker forward n
}
}
デフォルトの Supervisor 戦略をオーバーライドできる
133. Manage failure
class Worker extends Actor {
...
override def preRestart(
reason: Throwable, message: Option[Any]) {
... // clean up before restart
}
override def postRestart(reason: Throwable) {
... // init after restart
}
}
故障の管理
135. Remote deployment
Just feed the ActorSystem with this configuration
akka {
actor {
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote =
}
}
}
}
リモート配備: ActorSystem にこの設定を渡すだけ
136. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
actor {
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote =
}
}
}
}
リモート配備: ActorSystem にこの設定を渡すだけ
137. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote =
}
}
}
}
リモート配備: ActorSystem にこの設定を渡すだけ
138. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote =
}
}
Define Remote Path
}
}
リモート配備: ActorSystem にこの設定を渡すだけ
139. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote = akka://
}
}
Define Remote Path
} Protocol
}
リモート配備: ActorSystem にこの設定を渡すだけ
140. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote = akka://MySystem
}
}
Define Remote Path
} Protocol Actor System
}
リモート配備: ActorSystem にこの設定を渡すだけ
141. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote = akka://MySystem@machine1
}
}
Define Remote Path
} Protocol Actor System Hostname
}
リモート配備: ActorSystem にこの設定を渡すだけ
142. Remote deployment
Just feed the ActorSystem with this configuration
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote = akka://MySystem@machine1:2552
}
}
Define Remote Path
} Protocol Actor System Hostname Port
}
リモート配備: ActorSystem にこの設定を渡すだけ
143. Remote deployment
Just feed the ActorSystem with this configuration
Zero code changes
Configure a Remote Provider
akka {
For the Greeter actor {
actor
provider = akka.remote.RemoteActorRefProvider
deployment {
/greeter {
remote = akka://MySystem@machine1:2552
}
}
Define Remote Path
} Protocol Actor System Hostname Port
}
リモート配備: ActorSystem にこの設定を渡すだけ
144. Remote Lookup
val greeter = system.actorFor(
"akka://MySystem@machine1:2552/user/greeter")
リモートアクターを探す