Futures

Futures are mainly tokens returned by an actor that promises a result sometime in the future. The typical place one encounters a future is from an actor. The !! method of an actor returns a future. However in addition the Futures object provides several methods for doing parallel processing without having to write actors (or threads for that matter.)

Note: My use of scala.util.Random requires Scala 2.8 but I think the rest is 2.7.7.

1. scala> import scala.actors.Futures._                
2. import scala.actors.Futures._
4. /* 
5. The most basic future example.  
6. Just runs the function in a seperate thread and returns a Future object
7. for the result
8. */
9. scala> future {Thread.sleep(10000);println("hi");10}
10. res2: scala.actors.Future[Int] = < function0>
12. /* 
13. Use one of the future methods for obtaining the actual result
14. this one blocks tile ready, but other can check if result is ready and so on
15. */
16. scala> res2()
17. hi
18. res3: Int = 10
20. /*
21. This is more interesting. 
22. The method creates several futures and the using the awaitAll method 
23. waits for all the futures to complete before continuing
24. */
25. scala> def bubbles = {                                                                                                             
26.      | val bubbles = for( i <- 1 to 20) yield {
27.      |   future {
28.      |     Thread.sleep(scala.util.Random.nextInt(20)*500)
29.      |     println("pop "+i)
30.      |     "pop "+i
31.      |   }
32.      | }
33.      | awaitAll(30000, bubbles:_*) foreach println _                                                                               
34.      | }
35. bubbles: Unit
37. scala> bubbles
38. pop 9
39. pop 12
40. pop 11
41. pop 5
42. pop 3
43. pop 14
44. pop 20
45. pop 10
46. pop 1
47. pop 4
48. pop 16
49. pop 6
50. pop 7
51. pop 2
52. pop 8
53. pop 18
54. pop 15
55. pop 19
56. pop 17
57. pop 13
58. Some(pop 1)
59. Some(pop 2)
60. Some(pop 3)
61. Some(pop 4)
62. Some(pop 5)
63. Some(pop 6)
64. Some(pop 7)
65. Some(pop 8)
66. Some(pop 9)
67. Some(pop 10)
68. Some(pop 11)
69. Some(pop 12)
70. Some(pop 13)
71. Some(pop 14)
72. Some(pop 15)
73. Some(pop 16)
74. Some(pop 17)
75. Some(pop 18)
76. Some(pop 19)
77. Some(pop 20)
79. scala> import java.net._                                                                                        
80. import java.net._
82. scala> import scala.io._
83. import scala.io._
85. /*
86. A kind of funny example.  We set off two futures to download the google page
87. and print the first that finishes
88. */
89. scala> def load = {
90.      | val com = future {
91.      |   val comStream = new URL("http://www.google.com").openStream()                                                                       
92.      |   Source.fromInputStream(comStream).getLines().mkString("\n")
93.      | }
94.      | val ch = future {
95.      |   val chStream = new URL("http://www.google.ch").openStream()
96.      |   Source.fromInputStream(chStream).getLines().mkString("\n")
97.      | }  
98.      | awaitEither(ch,com)                                                                                               
99.      | }
100. load: Any
102. scala> load
103. res0: Any = 
104. & !doctype html...

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.