异步处理，使用Scala futures列表和onComplete进行异常处理

Question

我正在尝试进行大量的外部服务调用，每个调用都遵循异常处理和有条件的进一步处理。我认为使用内部的. on完成来扩展这个不错的（Scala中带有期货的异步IO）示例会很容易，但似乎我对范围和/或期货有些不理解。有人能给我指出正确的方向吗？

#!/bin/bash
scala -feature $0 $@
exit
!#

import scala.concurrent.{future, blocking, Future, Await}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._
import scala.util.{Success, Failure}
import scala.language.postfixOps

val keylist = List("key1", "key2")

val myFuts: List[Future[String]] = keylist.map {
  myid => future {
    // this line simulates an external call which returns a future (retrieval from S3)
    val myfut = future { Thread.sleep(1); "START " + myid}

    var mystr = "This should have been overwritten"
    myfut.onComplete {
      case Failure(ex) => {
        println (s"failed with error: $ex")
        mystr = "FAILED"
      }
      case Success(myval) => {
        mystr = s"SUCCESS $myid: $myval"
        println (mystr)
      }
    }
    mystr
  }
}

val futset: Future[List[String]] = Future.sequence(myFuts)
println (Await.result(futset, 10 seconds))

在我的电脑上(Scala 2.10.4 ),这打印出来:

SUCCESS key2: START key2
SUCCESS key1: START key1
List(This should have been overwritten, This should have been overwritten)

我要（顺序不重要）：

SUCCESS key2: START key2
SUCCESS key1: START key1
List(SUCCESS key2: START key2, SUCCESS key1: START key1)

Answer 1

完成后不会返回一个新的未来，它只允许您在未来完成时做一些事情。因此，未来的第一个块将在执行onComplete之前返回，因此您将返回字符串的原始值。

我们能做的就是用一个promise，去回报另一个未来，而这个未来是由第一个未来的结果来完成的。

  val keylist = List("key1", "key2")

  val myFuts: List[Future[String]] = keylist.map {
    myid => {
      // this line simulates an external call which returns a future (retrieval from S3)
      val myfut = Future {
        Thread.sleep(1); "START " + myid
      }
      var mystr = "This should have been overwritten"
      val p = Promise[String]()
      myfut.onComplete {
        case Failure(ex) =>
          println(s"failed with error: $ex")
          mystr = "FAILED"
          p failure ex
        case Success(myval) =>
          mystr = s"SUCCESS $myid: $myval"
          println(mystr)
          p success myval
      }
      p.future
    }
  }

  val futset: Future[List[String]] = Future.sequence(myFuts)
  println(Await.result(futset, 10 seconds))

超级方便的是mapAll方法，正如我在这里所问的那样：为成功和失败绘制未来地图

Answer 2

我会避免使用 onComplete 并尝试使用它来对可变变量进行副作用逻辑。相反，我会映射未来，并将失败情况处理为返回不同的值。下面是一个稍微修改过的代码版本，使用 map on the Future（通过 a 进行理解），然后使用 recover 来处理失败的情况。希望这就是你一直在寻找的：

val keylist = List("key1", "key2")

val myFuts: List[Future[String]] = keylist.map {myid => 

  // this line simulates an external call which returns a future (retrieval from S3)
  val myfut = future { Thread.sleep(1); "START " + myid}
  val result = for (myval <- myfut) yield {
    val res = s"SUCCESS $myid: $myval"
    println(res)
    res
  }
  result.recover{
    case ex => 
      println (s"failed with error: $ex")
      "FAILED"          
  }

}

val futset: Future[List[String]] = Future.sequence(myFuts)
println (Await.result(futset, 10 seconds))