How to undo the future in Scala?

Question

Java Future has a cancel method that can interrupt the thread that runs the Future task. For example, if I complete an intermittent blocking call in Java Future , I can interrupt it later.

Scala Future does not provide a cancel method. Suppose I end an intermittent blocking call in Scala Future . How can I interrupt him?

Answer 1

This is not yet part of the Future API, but may be added as an extension in the future.

As a workaround, you can use firstCompletedOf to wrap 2 futures - the future you want to cancel and the future that comes from custom Promise . Then you can cancel the future created in this way without fulfilling the promise:

 def cancellable[T](f: Future[T])(customCode: => Unit): (() => Unit, Future[T]) = { val p = Promise[T] val first = Future firstCompletedOf Seq(p.future, f) val cancellation: () => Unit = { () => first onFailure { case e => customCode} p failure new Exception } (cancellation, first) } 

Now you can call this in any future to get a "cancelable wrapper". Usage example:

 val f = callReturningAFuture() val (cancel, f1) = cancellable(f) { cancelTheCallReturningAFuture() } // somewhere else in code if (condition) cancel() else println(Await.result(f1)) 

EDIT:

For a detailed discussion of cancellation, see Chapter 4 in Teaching Parallel Programming in Scala .

Answer 2

I have not tested this, but it has expanded to answer Pablo Francisco Perez Hidalgo. Instead of blocking the java Future wait, we use an intermediate Promise instead.

 import java.util.concurrent.{Callable, FutureTask} import scala.concurrent.{ExecutionContext, Promise} import scala.util.Try class Cancellable[T](executionContext: ExecutionContext, todo: => T) { private val promise = Promise[T]() def future = promise.future private val jf: FutureTask[T] = new FutureTask[T]( new Callable[T] { override def call(): T = todo } ) { override def done() = promise.complete(Try(get())) } def cancel(): Unit = jf.cancel(true) executionContext.execute(jf) } object Cancellable { def apply[T](todo: => T)(implicit executionContext: ExecutionContext): Cancellable[T] = new Cancellable[T](executionContext, todo) } 

Answer 3

By canceling, I think, you would like to forcibly interrupt the future .

Found this code segment: https://gist.github.com/viktorklang/5409467

I did some tests and it seems to be working fine!

Enjoy :)

Answer 4

I think that you can reduce the complexity of the implementations provided with the Java 7 Future interface and its implementations.

Cancellable can build the future of Java, which will be canceled by its cancel method. Another future may await its completion, becoming an observable interface, which in itself is immutable in state:

  class Cancellable[T](executionContext: ExecutionContext, todo: => T) { private val jf: FutureTask[T] = new FutureTask[T]( new Callable[T] { override def call(): T = todo } ) executionContext.execute(jf) implicit val _: ExecutionContext = executionContext val future: Future[T] = Future { jf.get } def cancel(): Unit = jf.cancel(true) } object Cancellable { def apply[T](todo: => T)(implicit executionContext: ExecutionContext): Cancellable[T] = new Cancellable[T](executionContext, todo) }