Scala Actors

Scala Actors
Concurrency is an important topic in computer science. Advances in computer
architecture continue to push for greater levels of thread-­‐level parallelism. Moving
forward, computer languages must be able to efficiently and effectively implement
concurrency to remain viable.
Traditionally, concurrency can be handled using task-­‐based threads or event-­‐based
threads. Task-­‐based threading, as used by java, involves defining a ‘task’ to run as a
thread. To run a task-­‐based thread, a new thread is created and started to complete
the task and can then run in parallel to any other processing. When the thread has
completed its task, it is discarded.
Alternatively, Scala implements concurrency using event-­‐based actors. The name
actor can is telling of what an actor does. In performing arts, an actor is an
individual that has a role to perform and they can communicate with other actors by
communicating. Similarly, actors in Scala are objects that run concurrent processes
and can send and receive messages from other actors. Messages passed to an actor
are queue in the actor’s mailbox. Typically, an actor will perform pattern matching
on the message to determine what actions to take on the message.
The actor paradigm is considered to be easy to understand for the developer.
Additionally, the functional programming that is available to the Scala programmer
can improve the code design for concurrency by minimizing mutable state.
An example
Consider the following example. A familiar game played by kids is Marco Polo. In
this game, a player will call out “Marco”, to which a second player must respond
“Polo”. We can recreate this behavior using Scala and actors.
To be able to use actors, the following Scala libraries must be imported into the
application.
import scala.actors._
import scala.actors.Actor._
The package scala.actors includes the trait Actor that can be extend to create the
actor objects as well as all other classes, objects and traits related to actors. The
package scala.actors.Actor has methods that are used by the actor objects.
Next, define singleton objects to act as messages. These objects are declared to be
case objects as the receiving actor will use pattern matching to determine the action
to take.
1

case object Marco
case object Polo
case object Stop
Next, define the behavior of the player1 object with the class ‘Marco’.
class Marco(count: Int, player2: Actor) extends Actor {
def act() {
var tries = count - 1
player2 ! Marco
println("Marco...")
while (true) {
receive {
case Polo => {
if (tries > 1) {
println("Marco...")
player2 ! Marco
tries -= 1
} else {
player2 ! Stop
exit()
}
}
}
}
}
}
The Actors ‘act’ method is used to define the behavior of the Actor. A variable ‘tries’
is defined to limit the number of messages sent. Player1 initiates the game by
sending player2 the message ‘Marco’. In Scala, messages are sent to actors using the
‘!’ operator. Next, player1 continuously waits for the return ‘Polo’ message using the
‘receive’ method and pattern matching. Upon receiving the ‘Polo’ message, player1
will again send the ‘Marco’ message to player2 if the maximum number of tries has
not been reached. Once the number of tries has been reached, the actor exits.
Next, the behavior of player2 is defined with the class ‘Polo’.
class Polo extends Actor {
def act() {
while (true) {
receive {
2

case Marco => {
println("Polo...")
sender ! Polo
}
case Stop => {
exit()
}
}
}
}
}
The player2 object, implementing the ‘Polo’ class, waits in a loop to receive the
‘Marco’ message from player 1. Every time the actor receives the ‘Marco’ message, it
returns the ‘Polo’ message. Notice that the ‘Polo’ message is sent to the ‘sender’ as
opposed to explicitly sending the message player1. Sender refers to the actor that
sent the last received message.
Lastly, an object is defined that creates instances of the classes we created and starts
the actors.
object marcopolo extends Application {
val player2 = new Polo()
val player1 = new Marco(10, player2)
player1.start()
player2.start()
}
The following is the output of the compiling and running the previously described
function:
$ scalac marcopolo.scala
$ scala marcopolo
Polo...
Marco...
Polo...
Marco...
Polo...
Marco...
Polo...
Marco...
Polo...
3

Marco...
Polo...
Marco...
Polo...
Marco...
Polo...
Marco...
Polo...
act() method vs. actor{} function
In the previous example, we defined an actor’s ‘act’ method to define the behavior of
the actor. However, there is a second method to create an actor without creating a
class using the ‘actor’ function. For example, the ‘player2’ could be redefined to the
following:
val player2: Actor = actor {
while (true) {
receieve {
case Marco => {
println("Polo...")
sender ! Polo
}
case Stop => {
exit()
}
}
}
}
Here, the player2 actor is defined inline as opposed to instantiating an Actor class. It
is important to note that using this method, it is no longer necessary to class the
‘start’ method of the actor object. The actor is started immediately.
receive{} function vs. react{} function
In the previous example, we waited to for a message to return using the ‘receive’
function. The ‘receive’ function is a blocking function, meaning that the thread that
is currently executing the thread will be blocked until the message is received.
Using the receive message preserves the call stack.
4

In Scala, actors are executed on a thread pool that initially has 4 worker threads.
When the number of blocking threads increases, the size of the thread pool grows to
match. However, in situations with a large number of actors, it may be desirable to
avoid this blocking behavior.
Scala has a second method to return a message: the ‘react’ function. As opposed to
the ‘receive’ function, the ‘react’ function is non-­‐blocking. Instead of waiting for the
message to return, ‘react’ creates a closure. When the react function receives a
value, an available thread begins execution the actor. Take note, however, that the
react function cannot be used inside a while loop. As a result, Scala includes a ‘loop’
function to that behaves as an infinite loop and ‘loopWhile’ that behaves in a similar
manner to a while loop. Using the ‘react’ function instead of the ‘receive’ function
could be written as follows:
class Polo extends Actor {
def act() {
loop {
react {
case Marco => {
println("Polo...")
sender ! Polo
}
case Stop => {
exit()
}
}
}
}
}
In addition to the ‘react’ and ‘receive’ functions, Scala also includes ‘reactWithin’ and
‘receiveWithin’ functions. These functions work in the same way as the
corresponding ‘react’ and ‘receive’ functions but allow the programmer to specify a
timeout.
!, !!, and !?
In the previous example, messages were sent using the ‘!’ operator. Scala also
provides the ‘!?’ operator which will create a synchronous message. Instead of
returning like an asynchronous message, this operator waits for a reply. For
example the following code:
var response = player1 !? Polo
5

This code will send the Polo message to the object player1 and wait for a response,
which it will assign to the variable ‘response’.
Additionally, Scala has the ‘!!’ operator, which returns immediately. However, since
a message has not been received back, the operator returns a future instead. A
future is a representation of the response that allows to the caller to await the reply.
In this case, the blocking will occur only when trying to access the future.
This tutorial has presented a brief introduction to Scala actors. These concepts can
be extended to create far more complex and interesting code. The Scala distribution
includes a several examples of the use of Scala actors. These are available at /doc/scala-­‐devel-­‐docs/examples/actors/.
6

References
Tate, Bruce A. Seven Languages in Seven Weeks: A Pragmatic Guide to Learning
Programming Languages. Pragmatic Programmers, 2010.
Actors: A Short Tutorial. http://www.scala-­‐lang.org/node/242
Scala Standard Library 2.8.1 Final. http://www.scala-­‐lang.org/api/current/
index.html
Haller, Philipp and Martin Odersky. “Actors that Unify Threads and Events”. Lecture
Notes in Computer Science. Vol 4467, pp 171-­‐190, 2007.
7