Interruptible-Cancellable-scala.concurrent.Future

InterruptibleCancellableFuture.scala

/*
Copyright 2018 Viktor Klang
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

import scala.concurrent._
import java.util.concurrent.CancellationException

final class Interrupt extends (() => Boolean) {
  private[this] final var state: AnyRef = null
  override final def apply(): Boolean = this.synchronized {
    state match {
      case null        =>
        state = this
        true
      case _: this.type => false
      case t: Thread   =>
        state = this
        t.interrupt()
        true
    }
  }
  private[this] final def enter(): Boolean =
   this.synchronized {
     state match {
        case _: this.type => false
        case null =>
         state = Thread.currentThread
         true
     }
  }

  private[this] final def exit(): Boolean =
   this.synchronized {
     state match {
       case _: this.type => false
       case t: Thread =>
         state = this
         true
     }
  }

  def interruptibly[T](body: =>T): T =
    if (enter()) {
      try body catch {
        case ie: InterruptedException => throw new CancellationException()
      } finally {
        if(!exit() && Thread.interrupted()) 
          () // If we were interrupted and flag was not cleared
      }
    } else throw new CancellationException()
}

def interruptibly[T](body: => T)(implicit ec: ExecutionContext): (Future[T], () => Boolean) = {
    val interrupt = new Interrupt()
    (Future(interrupt.interruptibly(body))(ec), interrupt)
  }

I've updated the code, to only report successful cancellation if both interruption AND completion is successful

This is the only way to cancel future I found :)

But I can't figure out how can I use interruptableFuture to stop composed futures? For example

val f = Future {
    // blocking interruptable computation
  }.map(res => {
    // one more blocking interruptable computation
  })

How can I cancel future f?

could you explain the point behind passing Future to fun:
"fun: Future[T] => T"

instead of having just:
"fun: => T"
?

@minisaw Because when that Future is completed, the code knows that it has been interrupted, this is important in the case where the logic uses multiple threads underneath and you want to be able to propagate the interruption signal across them all (Thread.interrupted() is only for a single Thread.)

I think that this implementation is not easy to use. And if call the 'cancel' method was before actual starting the task execution, then the task will not be canceled and will be executed. I tried to fix these moments here https://gist.github.com/Tolsi/1c81840b6f132b8f69c2

@Tolsi You should introspect the Future provided to the function to determine whether you want to run or not.