Scala's Actor model for concurrent programming was originally inspired by the Erlang programming language.
The actor model is a system of asynchronous message passing for concurrent programming, rather than the typical shared data and locks model. The shared data and locks model has some inherent difficulties that make programming in this way difficult and error prone. Major problems with shared data and locks include the well known dead-lock problem, as well as live locks and the general problem of locking shared mutable data without affecting program scalability and performance. Whilst Scala's actor messaging framework is build around asynchronous messaging, synchronous messaging is provided on top of this for convenience.
The Scala's actor model is based around an actor library and the Actor trait, along with some simple syntactical constructs for sending and receiving messages.
The actor library can be included into a project using:
import scala.actors.Actor._
The simplest way to start an actor is to declare an object/class that extends the class Actor and in the body of the actor declare an act() {} method to do the work. The actor x can then be started much like a thread, using x.start(). The act() method is much like the Java Thread's run() method.
A more succinct method is to declare a variable val x = actor {} and put the action definition directly between the braces (no act method required). What happens here is that actor is a helper method on Actor that creates and starts the actor - so there is no need to call x.start() explicitly when using this approach.
Actors can receive messages using the receive {} method. The receive message is passed a partial function to receive the messages. Typically the body of the receive method uses case pattern matching to determine what to do with the message.
A message can be sent to an actor using the ! operation. For example, an Int can be sent to actor x using: x ! 3
All actors get their own thread to call the receive function - this causes scalability problems when there are many actors with receive functions. The way to overcome this in Scala is to use the react() {} method instead. React is similar to receive except it doesn't not need a native thread to run and but must call itself when done to receive more messages - apart from this both are the same in that they both take a partial function.
Scala provides a convenience to avoid having to call act/react within a react method, this is the loop construct. This ends up looking as simple as:
loop {
react {
// message handling body goes here
}
}
Note that react itself does not end end by returning up the call stack in the normal way, all calls to react result in an exception.
Within a receive or react method, an actor can reply to the sender of the received message by messaging the special identifier "sender", which represents the source of the message.
Example 1:
This simple example shows the most basic way to create an actor, by extending Actor, creating an instance and calling start on it.
package scalaactors1
import scala.actors._
class Actor1 extends Actor {
def act {
var x = 1
while (true) {
println("actor1! " + x)
x = x + 1
Thread.sleep(500)
}
}
}
object TestActors1 {
/**
* @param args the command line arguments
*/
def main(args: Array[String]) = {
println(">>main() - starting")
val actor1 = new Actor1()
actor1.start()
println("<<main() - ending")
}
}
Example 2:
This example creates a couple of actors using the val x = actor {} constructs. Each actor will automatically start and run concurrently, outputting a message and sleeping in an infinite loop. If you run this you can observe that the main thread starts and ends, the messages from the two actors are interleaved and run even after the main method has ended.
package scalaactors1
import scala.actors.Actor._
object TestActors2 {
/**
* @param args the command line arguments
*/
def main(args: Array[String]) = {
println(">>main() - starting")
val actor1 = actor {
var x = 1
while (true) {
println("actor1! " + x)
x = x + 1
Thread.sleep(500)
}
}
val actor2 = actor {
var x = 1
while (true) {
println("actor2! " + x)
x = x + 1
Thread.sleep(1000)
}
}
println("<<main() - ending")
}
}
Example 3:
This example is slightly more complex.
Actor kbReaderActor takes input from the keyboard (as Chars) and passes them one by one to the actor kbProcessorActor which prints out the received character and then uses a 3rd actor called sleep to sleep for the specified amount of time before then waking up the kbProcessorActor (to simulate some "work" that takes a finite amount of time to complete). Note that sleep signals the "sender" using a simple case class to represent the message type (with no arguments).
package scalaactors1
import scala.actors.Actor._
case class Wakeup // simple signalling case class
// simple actor example
object TestActors3 {
def main(args: Array[String]) = {
println(">>Starting")
val sleep = actor {
loop {
react {
case x : int => {
println("sleeping for " + x)
java.lang.Thread.sleep(x)
println("waking up sender...")
sender ! Wakeup
}
}
}
}
val keyProcessorActor = actor {
println(">>keyProcessorActor starting")
var key : Option[Char] = null
loop {
react {
case 'q' => exit() // 'q' signifies quit app!
case x : Char => println("keyProcessorActor received '" + x + "'")
sleep ! 1000 // ask the sleep actor to sleep, we will get a Wakeup call when done
// now wait for our wakeup
var r = false
do {
receive {
case Wakeup => r = true
}
} while (!r)
}
}
println("<<keyProcessorActor ending")
}
val kbReaderActor = actor {
println(">>kbReaderActor starting")
var key : Char = ' '
do {
println("kbReaderActor waiting for input")
val i = System.in.read()
key = i.asInstanceOf[Char]
println("Received input " + key)
// message actor1 with the key read from the console
keyProcessorActor ! key
} while (key != 'q')
println("<<kbReaderActor ending")
}
println("<<Application Ending")
}
}
.
Posts
