Introduction to Actors

The support for Actors is one of the features that attracts many new developers to Scala. It is not the only concurrancy construct in Scala but it is one of the most recognized.

An actor is essentially an active object. Instead of calling methods on the actor messages are passed to the actor and the message will be handled in a thread. Resources about actors can be found all over the internet a couple pages to look at are:

• Scala Actors: A Short Tutorial
• Event-Based Programming without Inversion of Control (PDF)
• Actors That Unify Threads and Events

This is a big topic about how threads are scheduled and so on but for now we will write a simple little program that downloads several webpages in parallel.

1. scala> import scala.actors.Actor
2. import scala.actors.Actor
4. scala> import Actor._
5. import scala.actors.Actor._
7. scala>  val collector = actor {
8.      |   var count = 3
9.      |   var data = ""
10.      |   loop {
11.      |   react { 
12.      |    case payload:String => {
13.      |      reply ("thank you")
14.      |      data += payload + "\n\n"
15.      |      count -= 1
16.      |      if (count == 0) {
17.      |        println (data)
18.      |        exit()
19.      |     }
20.      |    }
21.      |  }
22.      | }
23.      | }
24. collector: scala.actors.Actor = scala.actors.Actor$$anon$1@2bbef4c6
26. scala> import scala.io.Source
27. import scala.io.Source
29. scala> class Downloader(url:String) extends Actor {
30.      |  def act = {
31.      |   val source = Source.fromURL(new java.net.URL(url))
32.      |   val data = source.getLines.mkString("\n")
33.      |   collector ! data
34.      |   receive { case s => println("Done with "+url) }
35.      |  }
36.      | }
37. defined class Downloader
39. scala> List("http:/daily-scala.blogspot.com/2009/11/using-objects-as-functions.html",
40.      |      "http:/daily-scala.blogspot.com/2009/10/boolean-extractors.html",
41.      |      "http:/daily-scala.blogspot.com/2009/08/java-vs-scala-control-structures.html",
42.      |      "http:/www.blogger.com/profile/07600430363435495915")
43. res0: List[java.lang.String] = List(http:/daily-scala.blogspot.com/2009/11/using-objects-as-functions.html, http:/daily-scala.blogspot.com/2009/10/boolean-extractors.html, http:/daily-scala.blogspot.com/2009/08/java-vs-scala-control-structures.html, http:/www.blogger.com/profile/07600430363435495915)
45. scala> for (url <- res0) { 
46.      | new Downloader(url).start
47.      | }
49. [snip... lots of output]

Update:
If this program is put into a file and executed it will not finish is because the program exits. What is happening is there are 6 "actors" the main thread, collector and the 4 Downloaders. The main thread completes and shutdown the system taking all the Actors with it.

Just add link(collector) as the last line to make the main trhead wait for collector.

Also important to realize is that in Scala 2.7 an actor is lightweight. IE the application can exit while actors are still alive. In Scala 2.8 that is changed. For Scala 2.7 semantics you must use a DaemonActor instead of Actor.