Java: ExecutorService chặn khi gửi sau một kích thước hàng đợi nhất định

Tôi đang cố gắng viết mã một giải pháp trong đó một luồng duy nhất tạo ra các tác vụ chuyên sâu I / O có thể được thực hiện song song. Mỗi tác vụ có dữ liệu trong bộ nhớ quan trọng. Vì vậy, tôi muốn có thể giới hạn số lượng nhiệm vụ đang chờ xử lý tại một thời điểm.

Nếu tôi tạo ThreadPoolExecutor như thế này:

    ThreadPoolExecutor executor = new ThreadPoolExecutor(numWorkerThreads, numWorkerThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(maxQueue));

Sau đó, executor.submit(callable)ném RejectedExecutionExceptionkhi hàng đợi đầy và tất cả các luồng đã bận.

Tôi có thể làm gì để tạo executor.submit(callable)khối khi hàng đợi đã đầy và tất cả các luồng đang bận?

CHỈNH SỬA : Tôi đã thử cái này :

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

Và nó phần nào đạt được hiệu quả mà tôi muốn đạt được nhưng theo một cách không phù hợp (về cơ bản các luồng bị từ chối được chạy trong luồng đang gọi, vì vậy điều này chặn luồng gọi gửi thêm).

CHỈNH SỬA: (5 năm sau khi đặt câu hỏi)

Đối với bất kỳ ai đang đọc câu hỏi này và câu trả lời của nó, vui lòng không coi câu trả lời được chấp nhận là một giải pháp đúng. Vui lòng đọc qua tất cả các câu trả lời và nhận xét.

Tôi đã làm điều này tương tự. Bí quyết là tạo một BlockingQueue nơi phương thức offer () thực sự là một put (). (bạn có thể sử dụng bất kỳ cơ sở BlockingQueue nào bạn muốn).

public class LimitedQueue<E> extends LinkedBlockingQueue<E> 
{
    public LimitedQueue(int maxSize)
    {
        super(maxSize);
    }

    @Override
    public boolean offer(E e)
    {
        // turn offer() and add() into a blocking calls (unless interrupted)
        try {
            put(e);
            return true;
        } catch(InterruptedException ie) {
            Thread.currentThread().interrupt();
        }
        return false;
    }

}

Lưu ý rằng điều này chỉ hoạt động cho nhóm chủ đề, corePoolSize==maxPoolSizevì vậy hãy cẩn thận ở đó (xem nhận xét).

Đây là cách tôi giải quyết vấn đề này cuối cùng của tôi:

(lưu ý: giải pháp này chặn luồng gửi Callable, vì vậy nó ngăn RejectedExecutionException được ném)

public class BoundedExecutor extends ThreadPoolExecutor{

    private final Semaphore semaphore;

    public BoundedExecutor(int bound) {
        super(bound, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        semaphore = new Semaphore(bound);
    }

    /**Submits task to execution pool, but blocks while number of running threads 
     * has reached the bound limit
     */
    public <T> Future<T> submitButBlockIfFull(final Callable<T> task) throws InterruptedException{

        semaphore.acquire();            
        return submit(task);                    
    }


    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);

        semaphore.release();
    }
}

Câu trả lời hiện được chấp nhận có một vấn đề tiềm ẩn nghiêm trọng - nó thay đổi hành vi của ThreadPoolExecutor.execute sao cho nếu bạn có corePoolSize < maxPoolSize, logic ThreadPoolExecutor sẽ không bao giờ thêm nhân viên bổ sung ngoài lõi.

Từ ThreadPoolExecutor .execute (Runnable):

    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    else if (!addWorker(command, false))
        reject(command);

Cụ thể, khối 'else' cuối cùng đó sẽ không bao giờ bị đánh.

Một giải pháp thay thế tốt hơn là làm điều gì đó tương tự như những gì OP đang làm - sử dụng RejectedExecutionHandler để thực hiện cùng một putlogic:

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    try {
        if (!executor.isShutdown()) {
            executor.getQueue().put(r);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RejectedExecutionException("Executor was interrupted while the task was waiting to put on work queue", e);
    }
}

Có một số điều cần chú ý với cách tiếp cận này, như được chỉ ra trong các nhận xét (đề cập đến câu trả lời này ):

1. Nếu corePoolSize==0, sau đó có một điều kiện đua mà tất cả các luồng trong nhóm có thể chết trước khi nhiệm vụ được hiển thị
2. Việc sử dụng một triển khai bao bọc các tác vụ hàng đợi (không áp dụng cho ThreadPoolExecutor) sẽ dẫn đến sự cố trừ khi trình xử lý cũng kết thúc nó theo cách tương tự.

Hãy ghi nhớ những vấn đề đó, giải pháp này sẽ hoạt động đối với hầu hết các ThreadPoolExecutor điển hình và sẽ xử lý đúng trường hợp corePoolSize < maxPoolSize.

Tôi biết đây là một câu hỏi cũ nhưng có một vấn đề tương tự là tạo tác vụ mới rất nhanh và nếu có quá nhiều OutOfMemoryError xảy ra vì tác vụ hiện tại không được hoàn thành đủ nhanh.

Trong trường hợp của tôi đã Callablesđược gửi và tôi cần kết quả do đó tôi cần lưu trữ tất cả những gì được Futurestrả lại executor.submit(). Giải pháp của tôi là đặt Futuresvào một BlockingQueuevới kích thước tối đa. Khi hàng đợi đó đã đầy, không có tác vụ nào được tạo thêm cho đến khi một số tác vụ được hoàn thành (các phần tử bị xóa khỏi hàng đợi). Trong mã giả:

final ExecutorService executor = Executors.newFixedThreadPool(numWorkerThreads);
final LinkedBlockingQueue<Future> futures = new LinkedBlockingQueue<>(maxQueueSize);
try {   
    Thread taskGenerator = new Thread() {
        @Override
        public void run() {
            while (reader.hasNext) {
                Callable task = generateTask(reader.next());
                Future future = executor.submit(task);
                try {
                    // if queue is full blocks until a task
                    // is completed and hence no future tasks are submitted.
                    futures.put(compoundFuture);
                } catch (InterruptedException ex) {
                    Thread.currentThread().interrupt();         
                }
            }
        executor.shutdown();
        }
    }
    taskGenerator.start();

    // read from queue as long as task are being generated
    // or while Queue has elements in it
    while (taskGenerator.isAlive()
                    || !futures.isEmpty()) {
        Future compoundFuture = futures.take();
        // do something
    }
} catch (InterruptedException ex) {
    Thread.currentThread().interrupt();     
} catch (ExecutionException ex) {
    throw new MyException(ex);
} finally {
    executor.shutdownNow();
}

Tôi đã gặp vấn đề tương tự và tôi đã thực hiện điều đó bằng cách sử dụng các beforeExecute/afterExecutehook từ ThreadPoolExecutor:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Blocks current task execution if there is not enough resources for it.
 * Maximum task count usage controlled by maxTaskCount property.
 */
public class BlockingThreadPoolExecutor extends ThreadPoolExecutor {

    private final ReentrantLock taskLock = new ReentrantLock();
    private final Condition unpaused = taskLock.newCondition();
    private final int maxTaskCount;

    private volatile int currentTaskCount;

    public BlockingThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
            long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue, int maxTaskCount) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.maxTaskCount = maxTaskCount;
    }

    /**
     * Executes task if there is enough system resources for it. Otherwise
     * waits.
     */
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        taskLock.lock();
        try {
            // Spin while we will not have enough capacity for this job
            while (maxTaskCount < currentTaskCount) {
                try {
                    unpaused.await();
                } catch (InterruptedException e) {
                    t.interrupt();
                }
            }
            currentTaskCount++;
        } finally {
            taskLock.unlock();
        }
    }

    /**
     * Signalling that one more task is welcome
     */
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        taskLock.lock();
        try {
            currentTaskCount--;
            unpaused.signalAll();
        } finally {
            taskLock.unlock();
        }
    }
}

Điều này sẽ đủ tốt cho bạn. Btw, việc triển khai ban đầu dựa trên kích thước nhiệm vụ vì một nhiệm vụ có thể lớn hơn 100 lần so với nhiệm vụ khác và việc gửi hai nhiệm vụ lớn sẽ giết chết hộp, nhưng chạy một nhiệm vụ lớn và nhiều nhiệm vụ nhỏ thì được. Nếu các tác vụ chuyên sâu vào I / O của bạn có cùng kích thước, bạn có thể sử dụng lớp này, nếu không, chỉ cần cho tôi biết và tôi sẽ đăng cách triển khai dựa trên kích thước.

PS Bạn muốn kiểm tra ThreadPoolExecutorjavadoc. Đó là hướng dẫn sử dụng thực sự tuyệt vời của Doug Lea về cách nó có thể dễ dàng tùy chỉnh.

Tôi đã triển khai một giải pháp theo mẫu trang trí và sử dụng semaphore để kiểm soát số lượng tác vụ được thực thi. Bạn có thể sử dụng nó với bất kỳ Executorvà:

• Chỉ định tối đa các nhiệm vụ đang diễn ra
• Chỉ định thời gian chờ tối đa để đợi giấy phép thực thi tác vụ (nếu thời gian chờ trôi qua và không có giấy phép nào được cấp, a RejectedExecutionExceptionsẽ được ném)

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.Executor;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.Semaphore;

import javax.annotation.Nonnull;

public class BlockingOnFullQueueExecutorDecorator implements Executor {

    private static final class PermitReleasingDecorator implements Runnable {

        @Nonnull
        private final Runnable delegate;

        @Nonnull
        private final Semaphore semaphore;

        private PermitReleasingDecorator(@Nonnull final Runnable task, @Nonnull final Semaphore semaphoreToRelease) {
            this.delegate = task;
            this.semaphore = semaphoreToRelease;
        }

        @Override
        public void run() {
            try {
                this.delegate.run();
            }
            finally {
                // however execution goes, release permit for next task
                this.semaphore.release();
            }
        }

        @Override
        public final String toString() {
            return String.format("%s[delegate='%s']", getClass().getSimpleName(), this.delegate);
        }
    }

    @Nonnull
    private final Semaphore taskLimit;

    @Nonnull
    private final Duration timeout;

    @Nonnull
    private final Executor delegate;

    public BlockingOnFullQueueExecutorDecorator(@Nonnull final Executor executor, final int maximumTaskNumber, @Nonnull final Duration maximumTimeout) {
        this.delegate = Objects.requireNonNull(executor, "'executor' must not be null");
        if (maximumTaskNumber < 1) {
            throw new IllegalArgumentException(String.format("At least one task must be permitted, not '%d'", maximumTaskNumber));
        }
        this.timeout = Objects.requireNonNull(maximumTimeout, "'maximumTimeout' must not be null");
        if (this.timeout.isNegative()) {
            throw new IllegalArgumentException("'maximumTimeout' must not be negative");
        }
        this.taskLimit = new Semaphore(maximumTaskNumber);
    }

    @Override
    public final void execute(final Runnable command) {
        Objects.requireNonNull(command, "'command' must not be null");
        try {
            // attempt to acquire permit for task execution
            if (!this.taskLimit.tryAcquire(this.timeout.toMillis(), MILLISECONDS)) {
                throw new RejectedExecutionException(String.format("Executor '%s' busy", this.delegate));
            }
        }
        catch (final InterruptedException e) {
            // restore interrupt status
            Thread.currentThread().interrupt();
            throw new IllegalStateException(e);
        }

        this.delegate.execute(new PermitReleasingDecorator(command, this.taskLimit));
    }

    @Override
    public final String toString() {
        return String.format("%s[availablePermits='%s',timeout='%s',delegate='%s']", getClass().getSimpleName(), this.taskLimit.availablePermits(),
                this.timeout, this.delegate);
    }
}

Tôi nghĩ rằng nó đơn giản như sử dụng một ArrayBlockingQueuethay vì aa LinkedBlockingQueue.

Bỏ qua cho tôi ... điều đó hoàn toàn sai. ThreadPoolExecutorcuộc gọi Queue#offerkhông putcó hiệu lực mà bạn yêu cầu.

Bạn có thể mở rộng ThreadPoolExecutorvà cung cấp triển khai các execute(Runnable)cuộc gọi đó putthay cho offer.

Tôi e rằng đó không phải là một câu trả lời hoàn toàn thỏa đáng.