Related Articles More articles issued by Lightbend, Inc. Subscribe via RSS. Subscribe via ATOM. Contact Us.
Register Sign In. Email Print Friendly Share. Related Articles. This book picks up where the Akka documentation leaves off, exploring the how and the why of Akka, in a way that will empower you to grow your applications to new levels of scalability, responsiveness, and performance. Read more Read less.
Concurrency With Akka
Length: pages Language: English. Customers who bought this item also bought. Page 1 of 1 Start over Page 1 of 1. Implementing Domain-Driven Design. Vaughn Vernon. Scala Puzzlers.
FÃŒr andere kaufen
Andrew Phillips. Martin Kleppmann. Product description Product Description Writing truly concurrent software on the Java Virtual Machine just got a whole lot easier. See all Product description. Not Enabled. No customer reviews. Share your thoughts with other customers. Write a product review. Most helpful customer reviews on Amazon.
Verified Purchase. Even with all it's problems it is an excellent introduction to the "Actor" way of doing things.
After reading this book it is easy to figure out the specifics from the official docs or from various other more specialized "patterns" books out there. I have to disagree with the negative review. After a careful reading of this book I got quite a lot out of it - how to use schedulers, error kernel pattern, introduction to logging, FSM, structuring the application with actors, dead letters, watches, strategies, supervisors. The humor did not bother me. Alternatively, the actor may choose to ignore the message entirely i.
To implement an actor, it is necessary to extend the akka.
In comparison, the pattern-matching-based code makes it more immediately apparent what cases are being considered and how each is being handled.
Taking a complex problem and recursively splitting it into smaller sub-problems is a sound problem solving technique in general. This approach can be particularly beneficial in computer science consistent with the Single Responsibility Principle , as it tends to yield clean, modularized code, with little or no redundancy, that is relatively easy to maintain. In an actor-based design, use of this technique facilitates the logical organization of actors into a hierarchical structure known as an Actor System. The actor system provides the infrastructure through which actors interact with one another.
In Akka, the only way to communicate with an actor is through an ActorRef. Messages may be sent to an actor via an ActorRef using one of the following syntax protocols:. Each actor has a mailbox to which its incoming messages are delivered. There are multiple mailbox implementations from which to choose, with the default implementation being FIFO. An actor contains many instance variables to maintain state while processing multiple messages.
Akka ensures that each instance of an actor runs in its own lightweight thread and that messages are processed one at a time. Each actor is provided with the following useful information for performing its tasks via the Akka Actor API:. The parent actor will load each line from the file and then delegate to a child actor the task of counting the words in that line. When the child is done, it will send a message back to the parent with the result. The parent will receive the messages with the word counts for each line and keep a counter for the total number of words in the entire file, which it will then return to its invoker upon completion.
Note that the Akka tutorial code samples provided below are intended to be didactic only and therefore do not necessarily concern themselves with all edge conditions, performance optimizations, and so on. Also, a complete compilable version of the code samples shown below is available in this gist. This actor has a very simple task: consume ProcessStringMsg messages containing a line of text , count the number of words on the specified line, and return the result to the sender via a StringProcessedMsg message. Note that we have implemented our class to use the!
First, notice that the name of the file to process is passed to the WordCounterActor constructor line 3. This indicates that the actor is only to be used to process a single file.
locks - Why is Akka good for concurrency? - Software Engineering Stack Exchange
This also simplifies the coding job for the developer, by avoiding the need to reset state variables running , totalLines , linesProcessed , and result when the job is done, since the instance is only used once i. Once again, notice that in Akka, the sole mechanism for inter-actor communication is message passing. Messages are the only thing that actors share and, since actors can potentially access the same messages concurrently, it is important for them to be immutable, in order to avoid race conditions and unexpected behaviors.
It is therefore common to pass messages in the form of case classes since they are immutable by default and because of how seamlessly they integrate with pattern matching. Notice how this time the? In this way, the caller can use the returned Future to print the final result when this is available and to exit the program by shutting down the ActorSystem.