问题是,作为独立的方案,如果主要读物是在工人的校对之一之前终止,你可以执行“Hello Futurecode> 印本。 (新的未来图书馆间谍系 da子)

您也可使用<代码>Await的物体(也载于scala.con Current),等到未来f完成:

import scala.concurrent._
import scala.concurrent.util._

object Test {
  def main(args: Array[String]) {
    println("Test print before future")

    val s = "Hello"
    val f = future {s + " future!"}
    f onSuccess {case v => println(v)}
    println("Test print after future")

    Await.ready(f, Duration.Inf)
  }
}

This can print:

Test print before future
Test print after future
Hello future!

或者,它可以根据阅读时间表印刷“Hello Future”和“以后的试验”。

同样,你也可以强迫主线等到<代码>f>上填满最后l:

import scala.concurrent._
import scala.concurrent.util._

object Test {
  def main(args: Array[String]) {
    println("Test print before future")

    val s = "Hello"
    val f = future {s + " future!"}
    f onSuccess {case v => println(v)}

    Await.ready(f, Duration.Inf)        

    println("Test print after future")
  }
}

Which would print:

Test print before future
Hello future!
Test print after future

然而,请注意,在您使用<代码>Await时,您将再次加以阻挡。 当然,这是为了确保你的主要应用方式不会终止,但除非另有必要,否则一般不应使用。

(The Await object is a necessary escape hatch for situations like these, but using it throughout application code without concern for its semantics can result in slower, less-parallel execution. If you need to ensure that callbacks are executed in some specified order, for example, there are other alternatives, such as the andThen and map methods on Future.)

我认为,这里的问题是时机。 很可能,你未来的法典正在单独进行 de。 我认为,申请进展非常快,而这种 de魔的read光没有足够的时间加以适当执行(申请不会等待 de子的完结)。 但这也正是基于系统的行为。 对我来说,它印有:

Test print before future
Test print after future
Hello future!

and then exits (I m using Scala 2.10.0-M3). You can try following in order to test it - just put main execution thread in sleep for several seconds and see whether Hello future! is printed:

import scala.concurrent.Future
import scala.concurrent.future

object Test {
    def main(args: Array[String]) {
        println("Test print before future")

        val s = "Hello"
        val f = future {s + " future!"}
        f onSuccess {case v => println(v)}

        println("Test print after future")

        Thread.sleep(3000) 
        println("Test print at the end.")
    }
}

我只想补充一点,总的来说,还有另一个可能性是,未来不会运行: 点燃read池的极限。

在你看来,这很可能像其他人所指出的,只是一个时间问题,但作为未来参考,我们认为:

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration


object FutureDebug {
  def main( args: Array[String] ) {

    for (i <- Range(0, 4)) {
      future {
        while (true) {
          Thread.sleep(1000)
          println("I m doing stupid things in a future")
        }
      }
    }

    println("(1) reached? yes")
    val fut = future {
      for (i <- Range(0, 1000)) {
        println("never reached " + i)
      }
      3.14
    }    
    println("(2) reached? yes")
    Await.result(fut, Duration.Inf)
    println("(3) reached? no")
  }
}

在我的机器上,缺省的全球执行环境只有4条路面。 由于工人的read子忙于4个非专利的未来,以下未来将永远无法运行。 因此,在处理多个(实时)长期的未来时,应谨慎对待缺省执行情形,最好在。