Interruptible-Cancellable-scala.concurrent.Future

InterruptibleCancellableFuture.scala

import scala.concurrent._

  def interruptableFuture[T](fun: Future[T] => T)(implicit ex: ExecutionContext): (Future[T], () => Boolean) = {
    val p = Promise[T]()
    val f = p.future
    val lock = new Object
    var currentThread: Thread = null
    def updateCurrentThread(newThread: Thread): Thread = {
      val old = currentThread
      currentThread = newThread
      old
    }
    p tryCompleteWith Future {
      if (f.isCompleted) throw new CancellationException
      else {
        val thread = Thread.currentThread
        lock.synchronized { updateCurrentThread(thread) }
        try fun(f) finally { 
          val wasInterrupted = lock.synchronized { updateCurrentThread(null) } ne thread
          //Deal with interrupted flag of this thread in desired
        }
      }
    }

    (f, () => lock.synchronized {
      Option(updateCurrentThread(null)) exists {
        t =>
          t.interrupt()
          p.tryFailure(new CancellationException)
        }
      }
    )
  }