¿Utilizando el framework scala actor como cálculo de fork-join?

Question

¿Es posible, en teoría, utilizar el Marco de actores de Scala para realizar un tipo de cálculo asíncrono de división y conquista de manera similar al marco de unión de JDK 7? Si es así, ¿cómo podría expresar un problema de FJ con el marco, por ejemplo, el concepto de tutorial mergesort? Los códigos de código son bienvenidos.

(Llegué a la idea basada en un video de recursos que tengo en mi otra pregunta relacionada con FJ ).

Answer 1

Scala tiene paralelismo de estilo FJ. Es llamada de futuros y es parte de la biblioteca de actores.

import scala.actors.Future
import scala.actors.Futures._
def mergeSort[A <% Ordered[A]](xs : List[A]) : List[A] = {
// merge is not interesting, it''s sequential. The complexity lies in keeping it tail recursive
def merge[A <% Ordered[A]](accum : List[A], left : List[A], right : List[A]) : List[A] = {
(left, right) match {
case (lhead::ltail, rhead::rtail) =>
if (lhead <= rhead) merge(lhead :: accum, ltail, right)
else merge(rhead :: accum, left, rtail)
case (Nil, _) => accum reverse_::: right
case _ => accum reverse_::: left
}
}
// here''s the parallel sort bit
def sort[A <% Ordered[A]](xs : List[A], length : Int) : List[A] = {
if (length <= 1) xs
else {
val leftLength = length / 2
val rightLength = length - leftLength
val (left, right) = xs splitAt leftLength
// fork
val leftFork = future { sort(left, leftLength) }
val rightFork = future { sort(right, rightLength) }
// join
val leftJoin = leftFork()
val rightJoin = rightFork()
// merge
merge(Nil, leftJoin, rightJoin)
}
}
sort(xs, xs.length)
}

Ahora, al corazón de la pregunta. Si Scala no tuviera futuros, podrías escribir uno tú mismo basado en actores. En efecto. Se vería más o menos así.

import scala.actors.Actor
import scala.actors.Actor._
object MyFuture {
def apply[T](x : => T) : MyFuture[T] = {
val future = new MyFuture[T]
val act = actor {
react {
case sender : Actor => sender ! (future, x)
}
}
act ! self
future
}
}
class MyFuture[A] extends Function0[A] {
me =>
lazy val result = receive {
case (`me`, result) => result.asInstanceOf[A]
}
def apply() = result

}

Y lo usarías así

scala> val x = MyFuture(28 * 1000)
x: Foo.MyFuture[Int] = <function>
scala> x()
res4: Int = 28000