Используете Scala Actor Framework в качестве вычисления вилки-соединения? - PullRequest
Новая
       18

Используете Scala Actor Framework в качестве вычисления вилки-соединения?

16 голосов
/ 19 июля 2009

Возможно ли теоретически использовать платформу Scala Actor Framework для выполнения асинхронных вычислений типа "разделяй и властвуй", аналогично среде JDK 7 Fork-Join? Если да, то как я могу выразить проблему FJ с фреймворком - например, концепцию слияния учебника? Фрагменты кода приветствуются.

(я пришел к идее, основанной на ресурсном видео У меня есть другой мой вопрос о FJ .)

1 Ответ

33 голосов
/ 19 июля 2009

Scala имеет параллелизм в стиле FJ. Это колл фьючерс и он входит в библиотеку актеров 

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

Теперь к сути вопроса. Если бы у Scala не было будущего, вы могли бы написать его самостоятельно, основываясь на актерах. В самом деле. Это будет выглядеть более или менее так. 

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

}

И вы бы использовали это так 

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

scala> x()
res4: Int = 28000
...