通过scala.concurrent.Future传递异常？

是否有可能抛出异常，以逃避

未来的
上下文

scala> Future { Thread.sleep(3000); println("3 seconds elapsed"); 100 }
res2: scala.concurrent.Future[Int] = 
     scala.concurrent.impl.Promise$DefaultPromise@56113384

scala> 3 seconds elapsed

由于
未来
一经定义即“评估”：

Future
的定义是否可以通过
Future
上下文抛出异常

scala> Future { Thread.sleep(3000); println("3 seconds elapsed"); 100 }
res2: scala.concurrent.Future[Int] = 
     scala.concurrent.impl.Promise$DefaultPromise@56113384

scala> 3 seconds elapsed

我想不出这样的例子

scala> Future { throw new Exception("Foo!") }
res3: scala.concurrent.Future[Nothing] = 
  scala.concurrent.impl.Promise$DefaultPromise@47a86fbb

是的，但可能不是你想的那样。根据，只有非致命的错误才会逃逸。应用

 try Success(body) catch { case NonFatal(e) => Failure(e) }

i、 e.例外情况，如：
VirtualMachineError
，
OutOfMemoryError
，
stackoverflowererror
，
ThreadDeath
，
LinkageError
，
中断异常
，
ControlThrowable
。。将无法处理，因为它们代表了一个您无法处理的致命JVM错误。
是的，但可能不是您想象的那样。根据，只有非致命的错误才会逃逸。应用

 try Success(body) catch { case NonFatal(e) => Failure(e) }

i、 e.例外情况，如：
VirtualMachineError
，
OutOfMemoryError
，
stackoverflowererror
，
ThreadDeath
，
LinkageError
，
中断异常
，
ControlThrowable
。。将无法处理，因为它们代表了一个您无法处理的致命JVM错误。
是的，但可能不是您想象的那样。根据，只有非致命的错误才会逃逸。应用

 try Success(body) catch { case NonFatal(e) => Failure(e) }

i、 e.例外情况，如：
VirtualMachineError
，
OutOfMemoryError
，
stackoverflowererror
，
ThreadDeath
，
LinkageError
，
中断异常
，
ControlThrowable
。。将无法处理，因为它们代表了一个您无法处理的致命JVM错误。
是的，但可能不是您想象的那样。根据，只有非致命的错误才会逃逸。应用

 try Success(body) catch { case NonFatal(e) => Failure(e) }

i、 e.例外情况，如：
VirtualMachineError
，
OutOfMemoryError
，
stackoverflowererror
，
ThreadDeath
，
LinkageError
，
中断异常
，
ControlThrowable
。。因为它们代表了一个致命的JVM错误，您将无法处理。
未来本身除了定义计算之外什么都不做。碰巧您正在使用一个构造函数（或apply方法），默认情况下，该构造函数立即开始运行计算。不幸的是，异常处理和并发性的混合是scala.concurrent.Future中不明确的问题之一。更好的选择可能是使用
scalaz.concurrent.Task
，它将错误处理与显式并发结合起来
 未来本身除了定义计算之外什么都不做。碰巧您正在使用一个构造函数（或apply方法），默认情况下，该构造函数立即开始运行计算。不幸的是，异常处理和并发性的混合是scala.concurrent.Future中不明确的问题之一。更好的选择可能是使用
scalaz.concurrent.Task
，它将错误处理与显式并发结合起来
 未来本身除了定义计算之外什么都不做。碰巧您正在使用一个构造函数（或apply方法），默认情况下，该构造函数立即开始运行计算。不幸的是，异常处理和并发性的混合是scala.concurrent.Future中不明确的问题之一。更好的选择可能是使用
scalaz.concurrent.Task
，它将错误处理与显式并发结合起来
 未来本身除了定义计算之外什么都不做。碰巧您正在使用一个构造函数（或apply方法），默认情况下，该构造函数立即开始运行计算。不幸的是，异常处理和并发性的混合是scala.concurrent.Future中不明确的问题之一。更好的选择可能是使用
scalaz.concurrent.Task
，它将错误处理与显式并发结合起来
 你为什么要在将来犯错误

Future是一个monad，它将在您处理它时处理延迟和异常

如果您查看未来的实现，它如下所示：

trait Future[T] {    def onComplete(callback: Try[T] => Unit)(implicit exe..) }

所以，当您的未来完成并且值可用时，您的回调方法将被调用并返回单元

如果你看到回调方法，你就会知道你的结果是成功还是错误，并尝试为你管理所有的事情
 你为什么要在将来犯错误

Future是一个monad，它将在您处理它时处理延迟和异常

如果您查看未来的实现，它如下所示：

trait Future[T] {    def onComplete(callback: Try[T] => Unit)(implicit exe..) }

所以，当您的未来完成并且值可用时，您的回调方法将被调用并返回单元

如果你看到回调方法，你就会知道你的结果是成功还是错误，并尝试为你管理所有的事情
 你为什么要在将来犯错误

Future是一个monad，它将在您处理它时处理延迟和异常

如果您查看未来的实现，它如下所示：

trait Future[T] {    def onComplete(callback: Try[T] => Unit)(implicit exe..) }

所以，当您的未来完成并且值可用时，您的回调方法将被调用并返回单元

如果你看到回调方法，你就会知道你的结果是成功还是错误，并尝试为你管理所有的事情
 你为什么要在将来犯错误

Future是一个monad，它将在您处理它时处理延迟和异常

如果您查看未来的实现，它如下所示：

trait Future[T] {    def onComplete(callback: Try[T] => Unit)(implicit exe..) }

所以当