Java避坑指南:使用ExecutorCompletionService处理任务，而不处理返回值，导致OOM

java.util.concurrent.ExecutorCompletionService#submit(java.util.concurrent.Callable<V>)

java.util.concurrent.ExecutorCompletionService#submit(java.lang.Runnable, V)

java.util.concurrent.ExecutorCompletionService#take

java.util.concurrent.ExecutorCompletionService#poll()

 /**
     * Creates an ExecutorCompletionService using the supplied
     * executor for base task execution and a
     * {@link LinkedBlockingQueue} as a completion queue.
     *
     * @param executor the executor to use
     * @throws NullPointerException if executor is {@code null}
     */
    public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
            (AbstractExecutorService) executor : null;
        this.completionQueue = new LinkedBlockingQueue<Future<V>>();
    }

 this.completionQueue = new LinkedBlockingQueue<Future<V>>()

java.util.concurrent.FutureTask#done

 /**
     * Protected method invoked when this task transitions to state
     * {@code isDone} (whether normally or via cancellation). The
     * default implementation does nothing.  Subclasses may override
     * this method to invoke completion callbacks or perform
     * bookkeeping. Note that you can query status inside the
     * implementation of this method to determine whether this task
     * has been cancelled.
     */
    protected void done() { }

 /**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    public Future<V> submit(Runnable task, V result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<V> f = newTaskFor(task, result);
        executor.execute(new QueueingFuture<V>(f, completionQueue));
        return f;
    }

    public Future<V> take() throws InterruptedException {
        return completionQueue.take();
    }

    public Future<V> poll() {
        return completionQueue.poll();
    }

    public Future<V> poll(long timeout, TimeUnit unit)
            throws InterruptedException {
        return completionQueue.poll(timeout, unit);
    }

void solve (Executor e, Collection < Callable < Result >> solvers)  throws InterruptedException, ExecutionException {
            CompletionService<Result> cs = new ExecutorCompletionService<>(e);
            solvers.forEach(cs::submit);
            for (int i = solvers.size(); i > 0; i--) {
                Result r = cs.take().get();
                if (r != null) {
                    //do something
                };
            }
        }

void solve(Executor e, Collection<Callable<Result>> solvers) throws InterruptedException {
        CompletionService<Result> cs = new ExecutorCompletionService<>(e);
        int n = solvers.size();
        List<Future<Result>> futures = new ArrayList<>(n);
        Result result = null;
        try {
            solvers.forEach(solver -> futures.add(cs.submit(solver)));
            for (int i = n; i > 0; i--) {
                try {
                    Result r = cs.take().get();
                    if (r != null) {
                        result = r;
                        break;
                    }
                } catch (ExecutionException ignore) {
                }
            }
        } finally {
            futures.forEach(future -> future.cancel(true));
        }
        if (result != null) use(result);
    }

java.util.concurrent.ExecutorCompletionService#take

java.util.concurrent.ExecutorCompletionService#poll()