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)
  }

Stumbled across this recently… maybe I’m missing something, so hopefully you can help me out, but it seems strange to me to wrap the atomic set and getAndSetmethods on aref in a block that is synchronized on aref.

@dwhjames You're absolutely right, the reason for using AtomicReference was to get:
A) getAndSet — so I didn't need to implement that myself
B) unify the instance that holds the current Thread with the instance used as the monitor for the lock

See the updated version and compare it to the old :)

Huh, I was anticipating going the other way… implementing this entirely with AtomicReference. Am I missing something… does that not give you the desired semantics?

Gist it?

@viktorklang, see https://gist.github.com/dwhjames/8402617#file-interruptiblecancellablefuture-scala

Sorry, I’ve realized that I’ve split the conversation, as I added a comment on my gist with an analysis of the interleavings.

Maybe there is another issue here…

It is possible for wasInterrupted == false, but the promise to still be completed with the cancellation exception. In which case, the remainder of the finally block can’t execute anything that assumes success.

Similarly, one might be tempted to add code to act on wasInterrupted == true in some way, but tryCompleteWith could still beat tryFailure, right?

Adapting your code,

() => {
  var cancelled = false
  lock.synchronized {
    Option(updateCurrentThread(null)) foreach {
      _.interrupt()
     cancelled = p.failure(new CancellationException)
    }
  }
  cancelled
}

seems like a possible solution for avoiding the two interleavings described above (with some wrangling to retain the () => Boolean type).

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.