Einfache Scala Schauspieler Frage

Question

Ich bin sicher, dass dies eine sehr einfache Frage, aber peinlich ich meinen Kopf nicht drum herum kommen zu sagen:

Ich habe eine Liste von Werten in Scala. Ich möchte verwenden Sie Akteure, um einige (externe) Anrufe mit jedem Wert, parallel zu machen.

Ich möchte warten, bis alle Werte verarbeitet wurden, und dann fortfahren.

Es gibt keine gemeinsamen Werte, die geändert werden.

Könnte jemand beraten?

Dank

Answer 1

Es ist eine Schauspieler betriebene Klasse in Scala, die genau gemacht hat für diese Art von Problem: Futures. Dieses Problem würde so gelöst werden:

// This assigns futures that will execute in parallel 
// In the example, the computation is performed by the "process" function 
val tasks = list map (value => scala.actors.Futures.future { process(value) }) 

// The result of a future may be extracted with the apply() method, which 
// will block if the result is not ready. 
// Since we do want to block until all results are ready, we can call apply() 
// directly instead of using a method such as Futures.awaitAll() 
val results = tasks map (future => future.apply()) 

Dort gehen Sie. Nur das.

Answer 2

Arbeiter erstellen und sie bitten, für Futures !! verwendet wird; dann lese die Ergebnisse ab (die berechnet werden und parallel eingehen, sobald sie fertig sind; du kannst sie dann verwenden). Zum Beispiel:

object Example { 
    import scala.actors._ 
    class Worker extends Actor { 
    def act() { Actor.loop { react { 
     case s: String => reply(s.length) 
     case _ => exit() 
    }}} 
    } 
    def main(args: Array[String]) { 
    val arguments = args.toList 
    val workers = arguments.map(_ => (new Worker).start) 
    val futures = for ((w,a) <- workers zip arguments) yield w !! a 
    val results = futures.map(f => f() match { 
     case i: Int => i 
     case _ => throw new Exception("Whoops--didn't expect to get that!") 
    }) 
    println(results) 
    workers.foreach(_ ! None) 
    } 
} 

Dies hat eine sehr kostengünstige Berechnung - die Länge eines Strings Berechnung - aber man kann etwas teuer dort setzen, um sicherzustellen, dass es wirklich parallel geschieht (das Letzte, was Falle der Akt Block sollte sein, mit der Antwort zu antworten). Beachten Sie, dass wir auch einen Fall für den Arbeiter einschließen, um sich selbst zu schließen, und wenn wir fertig sind, sagen wir den Arbeitern, dass sie herunterfahren sollen. (In diesem Fall wird jeder nicht-String schließt die Arbeiter nach unten.)

Und wir können dies sicher zu machen versuchen, es funktioniert:

scala> Example.main(Array("This","is","a","test")) 
List(4, 2, 1, 4)