将异步计算包装为同步（阻塞）计算

Question

我有一个对象，该对象带有一种方法，希望以类似以下方式向库客户端（尤其是脚本客户端）公开：

interface MyNiceInterface
{
    public Baz doSomethingAndBlock(Foo fooArg, Bar barArg);
    public Future<Baz> doSomething(Foo fooArg, Bar barArg);
    // doSomethingAndBlock is the straightforward way;
    // doSomething has more control but deals with
    // a Future and that might be too much hassle for
    // scripting clients
}

但是我可以使用的原始“东西”是一组事件驱动的类：

interface BazComputationSink
{
    public void onBazResult(Baz result);
}

class ImplementingThing
{
    public void doSomethingAsync(Foo fooArg, Bar barArg, BazComputationSink sink);
}

在其中，ImplementingThing接受输入，执行一些不可思议的工作，例如将任务排队入队列，然后稍后在发生结果时，sink.onBazResult()在可能与调用ImplementingThing.doSomethingAsync（）相同的线程上调用该线程。

有没有一种方法可以使用我拥有的事件驱动功能以及并发原语来实现MyNiceInterface，以便脚本客户端可以愉快地等待阻塞线程？

编辑：
我可以为此使用FutureTask吗？

Answer 1

使用您自己的Future实现：

public class BazComputationFuture implements Future<Baz>, BazComputationSink {

    private volatile Baz result = null;
    private volatile boolean cancelled = false;
    private final CountDownLatch countDownLatch;

    public BazComputationFuture() {
        countDownLatch = new CountDownLatch(1);
    }

    @Override
    public boolean cancel(final boolean mayInterruptIfRunning) {
        if (isDone()) {
            return false;
        } else {
            countDownLatch.countDown();
            cancelled = true;
            return !isDone();
        }
    }

    @Override
    public Baz get() throws InterruptedException, ExecutionException {
        countDownLatch.await();
        return result;
    }

    @Override
    public Baz get(final long timeout, final TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
        countDownLatch.await(timeout, unit);
        return result;
    }

    @Override
    public boolean isCancelled() {
        return cancelled;
    }

    @Override
    public boolean isDone() {
        return countDownLatch.getCount() == 0;
    }

    public void onBazResult(final Baz result) {
        this.result = result;
        countDownLatch.countDown();
    }

}

public Future<Baz> doSomething(Foo fooArg, Bar barArg) {
    BazComputationFuture future = new BazComputationFuture();
    doSomethingAsync(fooArg, barArg, future);
    return future;
}

public Baz doSomethingAndBlock(Foo fooArg, Bar barArg) {
    return doSomething(fooArg, barArg).get();
}

该解决方案在内部创建一个CountDownLatch，一旦收到回调，该计数器将被清除。如果用户调用get，则使用CountDownLatch阻止调用线程，直到计算完成并调用onBazResult回调。CountDownLatch将确保如果回调在调用get（）之前发生，则get（）方法将立即返回结果。