Eine leichtgewichtige Scala-Fork-Join-Syntax

Question

Trotz des kommenden Java 7 Standard-Fork/Join-Frameworks baue ich eine Hilfsmethode, die in der Syntax leichtgewichtig ist, damit der Client den Code parallel ausführen kann. Hier ist eine lauffähige Hauptmethode zur Veranschaulichung der Idee.

import actors.Futures

object ForkTest2 {

  def main(args: Array[String]) {
    test1
    test2
  }

  def test1 {
    val (a, b, c) =fork({
      Thread.sleep(500)
      println("inside fx1 ",+System.currentTimeMillis)
      true
    }, {
      Thread.sleep(1000)
      println("inside fx2 ",+System.currentTimeMillis)
      "stringResult"
    }, {
      Thread.sleep(1500)
      println("inside fx3 ",+System.currentTimeMillis)
      1
    })

    println(b, a, c)
    true
  }

  def test2 {
    val results = forkAll({
      () =>
              Thread.sleep(500)
              println("inside fx1 ",+System.currentTimeMillis)
              true
    }, {
      () =>
              Thread.sleep(1000)
              println("inside fx2 ",+System.currentTimeMillis)
              "stringResult"
    }, {
      () =>
              Thread.sleep(1500)
              println("inside fx3 ",+System.currentTimeMillis)
              1
    }, {
      () =>
              Thread.sleep(2000)
              println("inside fx4 ",+System.currentTimeMillis)
              1.023
    })

    println(results)
    true
  }

  val tenMinutes = 1000 * 60 * 10

  def fork[A, B, C](
          fx1: => A,
          fx2: => B,
          fx3: => C
          ) = {
    val re1 = Futures.future(fx1)
    val re2 = Futures.future(fx2)
    val re3 = Futures.future(fx3)
    //default wait 10 minutes
    val result = Futures.awaitAll(tenMinutes, re1, re2, re3)
    (
            result(0).asInstanceOf[Option[A]],
            result(1).asInstanceOf[Option[B]],
            result(2).asInstanceOf[Option[C]]

            )
  }

  type fxAny = () => Any

  def forkAll(
          fx1: fxAny*
          ): List[Any] = {
    val results = fx1.toList.map {fx: fxAny => Futures.future(fx())}
    Futures.awaitAll(tenMinutes, results: _*)
  }
}

Ein Beispiel für eine Ausgabe ist

(inside fx1 ,1263804802301)
(inside fx2 ,1263804802801)
(inside fx3 ,1263804803301)
(Some(stringResult),Some(true),Some(1))
(inside fx1 ,1263804803818)
(inside fx2 ,1263804804318)
(inside fx3 ,1263804804818)
(inside fx4 ,1263804805318)
List(Some(true), Some(stringResult), Some(1), Some(1.023))

Test 1 veranschaulicht einen typsicheren Rückgabetyp

Test 2 veranschaulicht ein beliebiges Eingangsargument

Ich hoffe, dass ich die beiden Testmethoden kombinieren kann, damit der Client-Code eine beliebige Funktion parallel mit einem sicheren Rückgabetyp ausführen kann.

Ein weiterer Punkt in Bezug auf beliebige Funktionsargumente ist:

Ich denke, die Linie

  type fxAny = () => Any

sollte eigentlich folgender Code sein

  type fxAny =  => Any

, aber der Scala-Compiler erlaubt mir das nicht.

Wir sind für jede Hilfe dankbar.