如何在Scala中违背诺言

Question

在Scala文档中，有一个例子说明了如何通过使用promise来选择更快成功的未来。

http://docs . Scala-lang . org/overviews/core/futures . html # promises

def first[T](f: Future[T], g: Future[T]): Future[T] = {
  val p = promise[T]
  f onSuccess {
    case x => p.trySuccess(x)
  }
  g onSuccess {
    case x => p.trySuccess(x)
  }
  p.future
}

这个函数返回先成功的未来，如果其中任何一个失败，它永远不会完成。

是否有可能以这样一种方式修改它，即即使其他未来失败，如果第二个成功，则返回第二个，如果两个都成功，则选择更快的一个，就像代码现在所做的那样。

Answer 1

以下是一个基本模式，用于选择最快的未来或在它们都太慢时超时：

import scala.concurrent._
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{ Success, Failure }
import akka.actor._
import akka.pattern.after

object GetFastestFutureOrTimeout extends App {
  val e = new TimeoutException("TimeoutException")
  val system = ActorSystem("GetFastestFutureOrTimeout")
  val f1 = Future { Thread.sleep(200); "this is f1" }
  val f2 = Future { Thread.sleep(100); "this is f2" }
  val timeoutFuture = after(500.milliseconds, using = system.scheduler) { Future.failed(e) }
  val f = Future.firstCompletedOf(f1 :: f2 :: timeoutFuture :: Nil)

  f onComplete {
    case Success(msg) => println(msg)
    case Failure(err) => println("An error occured: " + err.getMessage)
  }
}

打印“这是f2”。如果timeoutFuture的超时时间更改为50，它将打印“发生错误：TimeoutException”。

firstCompletedOf使用一个promise来返回第一个完成的Future的值，请参见https://github . com/Scala/Scala/blob/v 2 . 11 . 6/src/library/Scala/concurrent/Future . Scala # L503。

Answer 2

我建议您遵循阿尔文·亚历山大关于Scala未来和promise的建议

我相信这是处理期货的最佳方式

package futures

import scala.concurrent.{Future => ConcurrentTask}           // rename
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}
import Utils.sleep

object FutureAsConcurrentTask extends App {

  // run some long-running task (task has type Future[Int] in this example)
  val task = ConcurrentTask {
    Cloud.executeLongRunningTask
  }

  // whenever the task completes, execute this code
  task.onComplete {
    case Success(value) => println(s"Got the callback, value = $value")
    case Failure(e) => println(s"D'oh! The task failed: ${e.getMessage}")
  }

  // do your other work
  println("A ..."); sleep(100)
  println("B ..."); sleep(100)
  println("C ..."); sleep(100)
  println("D ..."); sleep(100)
  println("E ..."); sleep(100)
  println("F ..."); sleep(100)

}

Answer 3

您可以添加以下内容：

f onFailure {
  case e =>
    g onFailure {
      case _ =>
        p.failure(e)
    }
}

当两个期货都失败时，这将使promise失败，例外情况与< code>f相同。如果需要，您可以详细说明这一点，创建一个异常来记录来自< code>f和< code>g的两个异常。