CS计算机代考程序代写 Java flex NWEN303 Concurrent Programming

NWEN303 Concurrent Programming
13: Actors and Message Passing
Marco Servetto VUW

●
●
●
– –
–
Actors
An actor is a Worker that communicate with other workers strictly by message passing.
What is a Message? — every approach have its own idea.
Most common implementations for messages:
event in a state machine (theoretical approach)
method call of an object in an OO language (typed approach)
objects in an OO language (flexible approach)

● ● ●
–
– –
●
Computation can be on a single machine with multi-threading or on multiple machines in a distributed setting by changing the configuration
Actors — AKKA
We will use the popular Java actor library AKKA.
Very large library, we can not learn it all! Show only ActorSystems with fixed topology:
all actors are created and initialized before any message is sent.
all actors stop at the end when the result is ready
the whole actor system is encapsulated in a method execution

Actors — AKKA
We will not see: (you can try to learn those on your own after the course)
● Hierarchies of Actors: In Akka any actor is the descendant of some other actor that is his supervisor. Organizing the actors in trees allows to perform sub-computations in a flexible manner.
● Fault tolerance: how to continue your distributed computation even if some process/machine goes down, and is restated after a while.
● Clustering: efficient and flexible ways to handle many machines and to automatically distribute the computation load coming from external requests.
● Details of the Actors life cycles: actors objects can be restarted outside of the control of the programmer. This allows for example to move them on another physical machine.
● Logging, Testing and Debugging: Akka comes with its own ways to log, test and debug actor based applications. They are mostly useful to track the other aspects that we are not seeing in this course.

Actors: first look/ first shock!
class A extends AbstractActor{//the Akka class to create actors
void onString(String s){//my own methods, not @Override System.out.println(“‘A’ handles the message ‘”+s+”‘”); this.sender().tell(“‘A’ have received ‘”+s+”‘”, self()); }
void onFoo(Foo s){..}
@Override public Receive createReceive(){//Akka way to dispatch return receiveBuilder()
.match(String.class,this::onString)//register your methods …
.match(Foo.class,this::onFoo)
.build();//Type based: messages are objects!
} }

Cakes with actors
public static Gift computeGift() throws InterruptedException{ ActorSystem s=AkkaConfig.newSystem(“Cakes”,2501, Map.of()); ActorRef alice=//makes wheat
s.actorOf(Props.create(Alice.class,()->new Alice()),”Alice”); ActorRef bob=//makes sugar
s.actorOf(Props.create(Bob.class,()->new Bob()),”Bob”); ActorRef charles=// makes cakes with wheat and sugar
s.actorOf(Props.create(Charles.class,()->new Charles()),”Charles”); ActorRef tim=//wants to eat 1000 cakes
s.actorOf(Props.create(Tim.class,()->new Tim()),”Tim”); //sending init messages
alice.tell(charles,tim);
bob.tell(charles,tim);
CompletableFuture