Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Interruptible-Cancellable-scala.concurrent.Future
/*
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)
}
@viktorklang
Copy link
Author

viktorklang commented Apr 4, 2015

@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.)

@Tolsi
Copy link

Tolsi commented Sep 11, 2015

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

@viktorklang
Copy link
Author

viktorklang commented Jun 28, 2016

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

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment