promise有缺陷吗？

Question

像这个问题的作者一样，我试图理解Scala 2.10的期货和promise中用户可见promise的原因。

特别是，再回到SIP的例子，它是不是完全有缺陷:

import scala.concurrent.{ future, promise }
val p = promise[T]
val f = p.future
val producer = future {
  val r = produceSomething()
  p success r
  continueDoingSomethingUnrelated()
}
val consumer = future {
  startDoingSomething()
  f onSuccess {
    case r => doSomethingWithResult()
  }
}

我正在想象对produceWhat的调用会导致运行时异常的情况。因为Promise和Producer-Future是完全分离的，这意味着系统挂起，消费者永远不会成功或失败。

因此，使用promise的唯一安全方式需要类似这样的东西

val producer = future {
  try {
    val r.produceSomething()
    p success r
  } catch {
     case e: Throwable =>
       p failure e
       throw e  // ouch
  }
  continueDoingSomethingUnrelated()
}

这显然容易出错和冗长。

对于可见的 promise 类型，我能看到的唯一情况是 m. A. D. 的答案中的回调钩子之一。但是SIP的例子对我来说没有意义。

Answer 1

Promise有一个completeWith（f：Future）方法，可以通过自动处理成功/失败场景来解决这个问题。

promise.completeWith( future {
  r.produceSomething
})

Answer 2

您可以使用< code>Promise来构建库中还没有的其他< code>Future组合子。

> < li>

“选择”关闭第一个未来得到满足。作为回报，剩余的期货作为一个序列:https://gist.github.com/viktorklang/4488970.

一种 after 方法，它返回在一段时间后完成的 Future，以“超时”Future：https://gist.github.com/3804710。

您需要Promises才能创建类似的其他组合器。

使用Promise使基于回调的API适应未来基于的API。例如：

def retrieveThing(key: String): Future[Thing] = {
  val p = Promise[Thing]()

  val callback = new Callback() {
    def receive(message: ThingMessage) {
      message.getPayload match {
        case t: Thing =>
          p success t        
        case err: SystemErrorPayload =>
          p failure new Exception(err.getMessage)
      }
    }
  }

  thingLoader.load(key, callback, timeout)
  p.future
}

使用Promise构建同步器。例如，为昂贵的操作返回缓存值，或计算它，但不要为同一个键计算两次：

private val cache = new ConcurrentHashMap[String, Promise[T]]

def getEntry(key: String): Future[T] = {
  val newPromise = Promise[T]()
  val foundPromise = cache putIfAbsent (key, newPromise)

  if (foundPromise == null) {
    newPromise completeWith getExpensive(key)
    newPromise.future
  } else {
    foundPromise.future
  }
}

Answer 3

这就是为什么您很少使用成功和失败，除非您已经知道某些东西是防弹的。如果您想要防弹，这就是try的作用：

val producer = future {
  p complete Try( produceSomething )
  continueDoingSomethingUnrelated()
}

似乎没有必要再次抛出错误；你已经通过把它打包到promise的答案里来处理它了，不是吗？(另外，请注意，如果< code>produceSomething本身返回一个未来值，您可以使用< code>completeWith来代替。)