Wait for Interrupted of CompletableTask.cancel about tascalate-concurrent HOT 4 CLOSED

import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Supplier;

import net.tascalate.concurrent.CompletableTask;
import net.tascalate.concurrent.Promise;

public class InterruptableFuture<T> extends CompletableFuture<T> {

	public static InterruptableFuture<Void> runAsync(Runnable runnable, Executor executor) {
		return submit(() -> {
			runnable.run();
			return null;
		}, executor);
	}

	public static <U> InterruptableFuture<U> submit(Callable<U> callable, Executor executor) {
		return new InterruptableFuture<>(callable, executor);
	}

	public static <U> InterruptableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor) {
		return new InterruptableFuture<>(supplier::get, executor);
	}

	private final Promise<Void> task;
	private final AtomicBoolean running = new AtomicBoolean(false);

	protected InterruptableFuture(Callable<T> callable, Executor executor) {
		task = CompletableTask.runAsync(() -> {
			if (running.compareAndSet(false, true)) {
				try {
					complete(callable.call());
				} catch (Exception e) {
					completeExceptionally(e);
				}
			}
			// if tryLock fail cancel has been already called
		}, executor);
	}

	@Override
	public boolean cancel(boolean mayInterruptIfRunning) {
		boolean cancelled = task.cancel(mayInterruptIfRunning);
		if (cancelled && running.compareAndSet(false, true)) {
			// task not started yet
			super.cancel(false);
		}
		return cancelled;
	}
}