simple Scala pregunta el actor

Question

Estoy seguro de que esta es una pregunta muy simple, pero vergüenza decir que no puedo conseguir mi cabeza alrededor de ella:

tengo una lista de valores en Scala. Me gustaría usar actores de uso para hacer algunas llamadas (externas) con cada valor, en paralelo.

Me gustaría esperar hasta que se hayan procesado todos los valores, y luego proceder.

No se han modificado los valores compartidos.

¿Alguien podría aconsejar?

Gracias

Answer 1

Hay una clase de actor y el uso de Scala que ha hecho precisamente por este tipo de problema: Futuros. Este problema se resolvería así:

// 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()) 

Ahí lo tiene. Solo eso.

Answer 2

Crear trabajadores y pedirles futuros utilizando !!; luego lea los resultados (que se calcularán y aparecerán en paralelo cuando estén listos; luego puede usarlos). Por ejemplo:

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) 
    } 
} 

Esto hace un cálculo muy barato - el cálculo de la longitud de una cadena - pero se puede poner algo caro allí para asegurarse de que realmente sucede en paralelo (la última cosa que el caso de la el bloque del acto debe ser responder con la respuesta). Tenga en cuenta que también incluimos un caso para que el trabajador se cierre solo, y cuando terminemos, les decimos a los trabajadores que se apaguen. (En este caso, cualquier no-cadena apaga el trabajador.)

y podemos probar esto para asegurarse de que funciona:

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