Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2:...
Transcript of Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2:...
![Page 1: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/1.jpg)
Programmation ConcurrenteCM7 - The Actor Model
Florian Brandner & Laurent PautetLTCI, Télécom ParisTech, Université Paris-Saclay
![Page 2: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/2.jpg)
xOutline
![Page 3: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/3.jpg)
Course Outline
• CM1: Introduction• CM2: The shared-memory model• CM3-6: Concurrent programming POSIX/Java (L. Pautet)
Patterns and Algorithms (L. Pautet)
• CM7: Actor-based programming (me)• Definition of actors• Actor primitives and concepts• Brief introduction to Akka Actor Library
• CM8: Transactional memory (me)
3/39
![Page 4: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/4.jpg)
xRecapture
![Page 5: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/5.jpg)
Shared-Memory Model
• All processors/threads share the same main memory• Data is exchanged through that memory• Data is shared through that memory• Threads synchronize through that memory
• Concurrent accesses• Might cause some troubles• Coherency: how do threads agree on the latest value?• Consistency: in which order do updates appear globally⇒ Memory models cover both aspects
Is this the only model?
5/39
![Page 6: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/6.jpg)
Shared-Memory Model
• All processors/threads share the same main memory• Data is exchanged through that memory• Data is shared through that memory• Threads synchronize through that memory
• Concurrent accesses• Might cause some troubles• Coherency: how do threads agree on the latest value?• Consistency: in which order do updates appear globally⇒ Memory models cover both aspects
Is this the only model?
5/39
![Page 7: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/7.jpg)
Sockets
Do not require shared memory:• Allow to send messages over a network
• Various protocols possible (UDP, TCP/IP, . . . )• Receiver has to listen for messages (recv, recvfrom)• Similar interface as regular files
• Name vs. addresses• Machine names to find receiver (gethostbyname)• No common naming of services (port numbers)
• Available almost everywhere (C, Java, . . . )• But cumbersome to use• Can we do better?
Can we generalize this?
6/39
![Page 8: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/8.jpg)
Sockets
Do not require shared memory:• Allow to send messages over a network
• Various protocols possible (UDP, TCP/IP, . . . )• Receiver has to listen for messages (recv, recvfrom)• Similar interface as regular files
• Name vs. addresses• Machine names to find receiver (gethostbyname)• No common naming of services (port numbers)
• Available almost everywhere (C, Java, . . . )• But cumbersome to use• Can we do better?
Can we generalize this?
6/39
![Page 9: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/9.jpg)
xThe Message-Passing Model
![Page 10: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/10.jpg)
Message Passing between Computers
General concept, with many different implementations:• Several processors in potentially many computers• No globally shared memory accessible to all processors• Information exchange is based on messages
Network
I/D$ I/D$I/D$ I/D$
CPU0 CPU1 CPU2 CPU3
Memory Memory Memory Memory
8/39
![Page 11: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/11.jpg)
Main Issues
Very different problems (w.r.t. shared-memory model):• How is data exchanged?
(point-to-point messages, broad-, multi-cast)
• How are data and computations distributed?(computations impossible without data)
• How can one balance the load between computations atprocessors and the communication over the network?
⇒ Coarser form of parallelism due to cost of communication⇒ Almost exclusively controlled by programmer⇒ (few tools available)
9/39
![Page 12: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/12.jpg)
Implementations
Several programming frameworks/languages are based onmessage passing:
• OpenMPI (http://www.open-mpi.org/)C, C++, Fortran library for large-scale parallel computingusing message passing (often used in scientific computing)
• Erlang (http://www.erlang.org/)Old functional programming language that was recentlyrediscovered. Parallelism is based on actors(computations), which exchange information throughmessage passing.
• Stream programming (StreamIt) and synchronousprogramming languages (Lustre, Esterel, SCADE)
• . . .
10/39
![Page 13: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/13.jpg)
xThe Actor Model
![Page 14: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/14.jpg)
Actors
Basic unit of computation:• Actors can communicate among each other• Actors can compute in response to a message• Actors can create other actors• Actors can designate how to handle the next message
Definition goes back to Carl Hewitt (70’s), and waslater refined by Gul Agha (80’s).
12/39
![Page 15: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/15.jpg)
Actors (2)
Additional features:• Each actor has a unique name• Each actor has its own private state (no global state)• Pending messages are kept in a mailbox1 (treated later)
1This is optional
13/39
![Page 16: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/16.jpg)
Communication
Weak guarantees concerning communication• Communication is one-way and asynchronous
(neither sender nor receiver is blocked)
• Messages are delivered in best-effort manner(messages may be lost or delayed infinitely)
• Message order is not defined, except:• A message is sent before it can be received• Even for messages of the same actor• No other guarantees
• Actors may communicate names of actors
14/39
![Page 17: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/17.jpg)
Computation
Messages are handled atomically by actors• Raise level of abstraction when reasoning about actors• Instead of micro steps (instructions) . . .• . . . use macro steps (handling of messages)• Absence of global state simplifies things
15/39
![Page 18: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/18.jpg)
How is an Actor implemented?
Simplistic model based on pseudo code:
while (true){
while (!mailbox.empty()){
// actor can chose which message to handle// next (e.g., through priorities)msg = mailbox.select_next_message()
// perform action depending on message typeswitch (msg){// create actors, send messages, compute, ...case ...case ...case ...
}}
}16/39
![Page 19: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/19.jpg)
Example: Actors
State
Code
Mailbox
State
Code
Mailbox
State
Code
Mailbox
create
send
send
17/39
![Page 20: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/20.jpg)
Example: Actors
State
Code
Mailbox
State
Code
Mailbox
State
Code
Mailbox
create
send
send
Could be a thread
Might be another machine
17/39
![Page 21: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/21.jpg)
xActor Semantics
![Page 22: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/22.jpg)
Encapsulation and Atomicity
• Actors do not share state• Data is exchanged using messages• Data is effectively copied
• Actors handle one message at a time• Many actors may work concurrently• However, each actor only processes one message at a time• Message processing appears atomic for external observers
This ensures the absence of race conditions on variables(deadlocks due to message processing are still possible).
19/39
![Page 23: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/23.jpg)
Fairness
• An actor makes progress whenever it has somecomputation to do
• An actor processes one of pending messages otherwise• Actors may still select which message to process next• This can be used to prioritize message processing
This ensures global progress of the entire system.
20/39
![Page 24: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/24.jpg)
Location Transparency
• The location of an actor does not affect its name• The location of an actor does not affect message passing
• After termination of an actor another may take its name• This is useful, for instance, to restart crashed actors• This can also be used to migrate actors from one location
to another
This improves robustness and portability.
21/39
![Page 25: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/25.jpg)
xCommunication Patterns
![Page 26: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/26.jpg)
RPC-like Requests
Messages are one-way, thus• Client and server need to send messages back and forth• Client has to remember that it waits for a reply• This is similar to remote procedure calls (RPC)
Client Service A Service BTime
1 strequest
1st rep
ly
2ndrequest
2ndreply
Remember towait for reply
23/39
![Page 27: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/27.jpg)
RPC-like Requests
Messages are one-way, thus• Client and server need to send messages back and forth• Client has to remember that it waits for a reply• This is similar to remote procedure calls (RPC)
Client
1st
reply
2nd
reply
Service A Service BTime
1 strequest
1st rep
ly
2ndrequest
2ndreply
Remember towait for reply
23/39
![Page 28: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/28.jpg)
Local Message Constraints
Messages acceptance may depend on history:• Actor may expect specific sequences of messages• Message acceptance may thus depend on the actor’s state• Predicates and message filters can be applied to mailbox
Client File Service
open
append|close
append|close
Time
open
opened
append
close
repeat
24/39
![Page 29: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/29.jpg)
Pipelining
Handle message sequences in parallel:• Similar to the idea of piplined processors (SE201)• Cascade of actors, each handling a step of the sequence• All of these actors work in parallel
Phase A Phase B Phase C Phase DTime
continue
continue
continue
25/39
![Page 30: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/30.jpg)
Divide and Conquer/Map-Reduce
Popular parallelization technique:• Divide work into smaller pieces• Scatter pieces to worker actors for processing• Gather replies to constitute final answer
Master Worker A Worker B Worker C Worker DTime
scatterscatter scatter
scatterscatter scatter
scatterscatter scatter
gathergathergather gathergathergather gathergathergather
26/39
![Page 31: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/31.jpg)
Combining Patterns
Patterns can of course be combined:• RPC-like requests combined with local constraints and pipelining• Note: the RPC request creates the second pipeline step
Client Phase A
append|close
append|close
File Service
open
open
open
Phase B
append|close
ClientTime
open
opened (A)
create
append open
opened (B)create
appendclose
27/39
![Page 32: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/32.jpg)
xThe Akka Actor Library
![Page 33: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/33.jpg)
Akka Actor Library
• Allows to implement actors in Java (also Scala)• Provides naming service (to find actors)• Provides communication service (for message passing)• Provides utility functions and classes
(fault-tolerance, watchdogs, . . . )
• Akka is open-source:2
http://akka.io/
2We use version 2.3.14 for Java 6.
29/39
![Page 34: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/34.jpg)
Actor Lifecycle in Akka
30/39
![Page 35: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/35.jpg)
Defining Actors
Simply by defining a new class:
import akka.actor.UntypedActor;
public class MyActor extends UntypedActor {@Overridepublic void onReceive(Object msg) {// code goes here. for now, ignore all messagesunhandled(msg);
}}
http://doc.akka.io/docs/akka/2.3.14/java/untyped-actors.html
31/39
![Page 36: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/36.jpg)
Instantiating an ActorFirst, define a Props, i.e., a kind of receipt:
import akka.actor.UntypedActor;import akka.actor.Props;import akka.japi.Creator;
public class MyActor extends UntypedActor {public static Props props() {return Props.create(new Creator<MyActor>() {private static final long serialVersionUID = 1L;
@Overridepublic MyActor create() throws Exception {
return new MyActor();}
});}
}
http://doc.akka.io/japi/akka/2.3.14/akka/actor/Props.html
32/39
![Page 37: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/37.jpg)
Instantiating and Initializing an ActorThen, instantiate the actor in the current context:
import akka.actor.UntypedActor;import akka.actor.Props;import akka.japi.Creator;import akka.actor.ActorRef;
public class MyActor extends UntypedActor {@Overridepublic void preStart() {// actually create actor and obtain an actor referencefinal ActorRef actorInstance =
getContext().actorOf(MyActor.props());
// send a message to the newly instantiated actoractorInstance.tell(1, getSelf());
}}
http://doc.akka.io/japi/akka/2.3.14/akka/actor/Actor.html
33/39
![Page 38: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/38.jpg)
Start-up of Akka Applications
Instantiate a first actor, which then takes over:
import akka.actor.UntypedActor;
public class MyActor extends UntypedActor {public static void main(String[] args) {
// Simply tell Akka to create an actor, which takes overakka.Main.main(new String[] { MyActor.class.getName() });
}}
http://doc.akka.io/japi/akka/2.3.14/akka/Main.html
34/39
![Page 39: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/39.jpg)
Actor SelectionFind actors using their names/paths:
import akka.actor.UntypedActor;import akka.actor.ActorSelection;
public class MyActor extends UntypedActor {public void mySendTo(String pattern) {// find all actors matching the patternActorSelection selection =
getContext().actorSelection(pattern);
// send the same message to all of the selected actorsselection.tell(2, getSelf());
}}
http://doc.akka.io/japi/akka/2.3.14/akka/actor/ActorSelection.html
35/39
![Page 40: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/40.jpg)
Message Passing
• Messages should be immutable(Java does not allow to enforce this, so its merely a convention)
• Three distinct primitives for sending:• Non-blocking without reply (tell())• Non-blocking providing a reply through a future (ask())• Forwarding of messages (forward())
• Message retrieval:• Automatically handled by Akka (onReceive())• Signal unexpected messages (unhandled())
36/39
![Page 41: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/41.jpg)
Additional Functions
Some utility functions• Use actor reference (ActorRef) to manipulate (other) actors:
• Get reference to current actor (getSelf())• Get sending actor of current message (getSender())• Get actor path and name (path().name())
• Use context to interact with the environment:• Create actors (getContext().actorOf())• Terminate actors (getContext().stop()))• Get parent actor (getContext().parent()))• Get child actors (getContext().children()))
• More functions:• Fault tolerance (monitoring, hot-swapping, watchdogs, . . . )• Message passing (routing, dispatching, mailboxes, . . . )• . . .
37/39
![Page 42: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/42.jpg)
Summary• Brief introduction to the Actors Model:
• Basic unit of computation• Only has private state• Reacts to incoming messages• Can create actors, compute, and send messages• Only communicates via messages (no global/shared state)
• Principles:• Encapsulation and atomicity• Fairness• Location transparency
• Communication patterns:• RPC-like requests (in Akka: ask())• Local message constraints (in Akka: stash())• Pipelining (in Akka: pipe())• Divide and conquer (map/reduce)
• Introduction to the Akka Actor Library
38/39
![Page 43: Programmation Concurrente - CM7 - The Actor Model · Course Outline • CM1: Introduction • CM2: The shared-memory model • CM3-6: Concurrent programming POSIX/Java (L. Pautet)](https://reader036.fdocuments.net/reader036/viewer/2022070709/5ebf28379d0a7815e94ea417/html5/thumbnails/43.jpg)
Further Reading
• Actor Model of Computation: Scalable Robust InformationSystems Carl Hewitt (arxiv, 2010-2015)
• ActorsRajesh K. Karmani and Gul Agha (Encyclopedia of ParallelComputing, 2011)
• Actors: A Model for Reasoning about Open distributed SystemsGul Agha, Prasannaa Thati, Reza Ziaei (Formal Methods forDistributed Processing: A Survey of Object-OrientedApproaches, 2001)
39/39