Question

我有以下工作代码：

DiscoveryCallback callback = new DiscoveryCallback();
Manager.discover(someparam, callback);

我想将此调用包装到CompletableFuture中，以使Rx-ish API与其他异步操作组合。

Manager.discover（）是第三方库的一种方法，实际上是对本机函数的绑定，它在不同的线程中多次执行回调。

My DiscoveryCallback实现以下界面：

interface onFoundListerner {
  onFound(List<Result> results)
  onError(Throwable error)
}

我尝试将一个CompletableFuture<List<Result>>实例注入DiscoveryCallback，然后调用complete方法。它适用于一个回调执行，其他被忽略。

如何加入这些多次执行的结果并使我的包装器返回一个CompletableFuture？

Answer 1

What about an asynchronous queue?

public class AsyncQueue<T> {
    private final Object lock = new Object();
    private final Queue<T> queue = new ArrayDeque<T>();
    private CompletableFuture<Void> removeCf = new CompletableFuture<>();

    public void add(T item) {
        synchronized (lock) {
            queue.add(item);
            removeCf.complete(null);
        }
    }

    public CompletableFuture<T> removeAsync() {
        CompletableFuture<Void> currentCf = null;
        synchronized (lock) {
            T item = queue.poll();
            if (item != null) {
                return CompletableFuture.completedFuture(item);
            }
            else {
                if (removeCf.isDone()) {
                    removeCf = new CompletableFuture<>();
                }
                currentCf = removeCf;
            }
        }
        return currentCf
            .thenCompose(v -> removeAsync());
    }
}

In Java 9, you can use .completeOnTimeout(null, timeout, unit) on the CompletableFuture returned by removeAsync to have a timeout mechanism.

Before Java 9, you need to schedule your own timeouts. Here's a version with an embedded timeout scheduler:

public class AsyncQueue<T> {
    static final ScheduledExecutorService scheduledExecutorService;

    static {
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1, new ScheduledThreadFactory());
        scheduledThreadPoolExecutor.setRemoveOnCancelPolicy(true);
        scheduledExecutorService = Executors.unconfigurableScheduledExecutorService(scheduledThreadPoolExecutor);
    }

    static final class ScheduledThreadFactory implements ThreadFactory {
        static AtomicInteger scheduledExecutorThreadId = new AtomicInteger(0);

        static final synchronized int nextScheduledExecutorThreadId() {
            return scheduledExecutorThreadId.incrementAndGet();
        }

        @Override
        public Thread newThread(Runnable runnable) {
            Thread thread = new Thread(runnable, "AsynchronousSemaphoreScheduler-" + nextScheduledExecutorThreadId());
            thread.setDaemon(true);
            return thread;
        }
    }

    private final Object lock = new Object();
    private final Queue<T> queue = new ArrayDeque<T>();
    private CompletableFuture<Long> removeCf = new CompletableFuture<>();

    public void add(T item) {
        synchronized (lock) {
            queue.add(item);
            removeCf.complete(System.nanoTime());
        }
    }

    public CompletableFuture<T> removeAsync(long timeout, TimeUnit unit) {
        if (unit == null) throw new NullPointerException("unit");

        CompletableFuture<Long> currentCf = null;
        synchronized (lock) {
            T item = queue.poll();
            if (item != null) {
                return CompletableFuture.completedFuture(item);
            }
            else if (timeout <= 0L) {
                return CompletableFuture.completedFuture(null);
            }
            else {
                if (removeCf.isDone()) {
                    removeCf = new CompletableFuture<>();
                }
                currentCf = removeCf;
            }
        }
        long startTime = System.nanoTime();
        long nanosTimeout = unit.toNanos(timeout);
        CompletableFuture<T> itemCf = currentCf
            .thenCompose(endTime -> {
                long leftNanosTimeout = nanosTimeout - (endTime - startTime);
                return removeAsync(leftNanosTimeout, TimeUnit.NANOSECONDS);
            });
        ScheduledFuture<?> scheduledFuture = scheduledExecutorService
            .schedule(() -> itemCf.complete(null), timeout, unit);
        itemCf
            .thenRun(() -> scheduledFuture.cancel(true));
        return itemCf;
    }

    public CompletableFuture<T> removeAsync() {
        CompletableFuture<Long> currentCf = null;
        synchronized (lock) {
            T item = queue.poll();
            if (item != null) {
                return CompletableFuture.completedFuture(item);
            }
            else {
                if (removeCf.isDone()) {
                    removeCf = new CompletableFuture<>();
                }
                currentCf = removeCf;
            }
        }
        return currentCf
            .thenCompose(endTime -> removeAsync());
    }
}

You can refactor the scheduler out of this class to share it with other classes, perhaps into a singleton which uses a factory set up in a .properties file and which resorts to the default in the example if not configured.

You can use a ReentrantLock instead of the synchronized statement to gain that little bit of performance. It should only matter under heavy contention, but AsyncQueue<T> could be used for such purposes.

在CompletableFuture中加入多个回调执行

1 个答案: