public boolean addCallback(Runnable cancellationHandler) {
        return cancellationToken.addCallback(cancellationHandler);
    }

    @Override
    public void removeCallback(Runnable cancellationHandler) {
        cancellationToken.removeCallback(cancellationHandler);
    }

    public boolean addCallback(Runnable cancellationHandler) {
        return cancellationToken.addCallback(cancellationHandler);
    }

    @Override
    public void removeCallback(Runnable cancellationHandler) {
        cancellationToken.removeCallback(cancellationHandler);
    }

    @Override
    public void cancel() {
        throw new UnsupportedOperationException();
    }

            }
        }
        if (returnValue) {
            cancellationHandler.run();
        }
        return returnValue;
    }

    @Override
    public void removeCallback(Runnable cancellationHandler) {
        synchronized (lock) {
            callbacks.remove(cancellationHandler);
        }
    }

    @Override
    public void cancel() {

    boolean addCallback(Runnable cancellationHandler);

    /**
     * Removes a callback called when cancellation request happens.
     *
     * @param cancellationHandler removed callback.
     */
    void removeCallback(Runnable cancellationHandler);

    /**
     * Removes a callback from a set of handlers called when cancel is requested.
     *
     * @param cancellationHandler removed callback.
     */
    void removeCallback(Runnable cancellationHandler);

            }
        };
    }

    public void start() {
        cancellationToken.addCallback(cancellationCallback);
    }

    @Override
    public void stop() {
        cancellationToken.removeCallback(cancellationCallback);
    }

        Runnable interrupt = thread::interrupt;
        try {
            cancellationToken.addCallback(interrupt);
            return delegate.execute(work, context);
        } finally {
            cancellationToken.removeCallback(interrupt);
            if (cancellationToken.isCancellationRequested()) {
                Thread.interrupted();
                throw new BuildCancelledException("Build cancelled while executing " + work.getDisplayName());

            buildCancellationToken.addCallback(cancellationCallback);
        }
    }

    @Override
    public void stop() {
        if (started.compareAndSet(true, false)) {
            buildCancellationToken.removeCallback(cancellationCallback);
        }
    }

    @NonNullApi
    private class KillWorkers implements Runnable {
        @Override
        public void run() {

            }
        } catch (InterruptedException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        } finally {
            cancellationToken.removeCallback(cancellationHandler);
        }
    }

    public boolean hasBeenTriggered() {
        return changeArrived;
    }

    public void notifyFileChangeArrived() {
        changeArrived = true;

    }

    def 'removed callback is not notified'() {
        def token = new DefaultBuildCancellationToken()

        def callback = Mock(Runnable)
        token.addCallback(callback)
        token.removeCallback(callback)

        when:
        token.cancel()

        then:
        token.cancellationRequested
        0 * callback.run()
    }