如果maximumPoolSize小于corePoolSize怎么办？Java 6中可能存在的错误？

Question

我在Java 6的ThreadPoolExecutor中遇到了一个奇怪的问题。当我不时地动态更改corePoolSize时，我观察到线程池并没有处理它应该处理的那个么多任务。

例如，如果我有4个作为corePoolSize，并且队列中有很多任务等待，那么执行器最多处理3个，有时甚至处理2个。

在调查这个问题时，我注意到当我增加或减少corePoolsize时，我从未更改过maxPoolsize。从我的应用程序开始，它一直是1。

在Java文档中从未发现一条语句提到maxPoolSize小于core的影响。

然后当我检查源代码时，我注意到在costructor和setCorePoolSize方法中，如果抛出非法的ArgumentException，它会在哪里检查max umPoolSize小于corePoolSize。检查下面的代码。

建造师

public ThreadPoolExecutor(
    int corePoolSize,
    int maximumPoolSize,
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory,
    RejectedExecutionHandler handler
) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
            throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

设置最大池大小

public void setMaximumPoolSize(int maximumPoolSize) {
    if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
        throw new IllegalArgumentException();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        int extra = this.maximumPoolSize - maximumPoolSize;
        this.maximumPoolSize = maximumPoolSize;
        if (extra > 0 && poolSize > maximumPoolSize) {
            try {
                Iterator<Worker> it = workers.iterator();
                while (it.hasNext() &&
                       extra > 0 &&
                       poolSize > maximumPoolSize) {
                    it.next().interruptIfIdle();
                    --extra;
                }
            } catch (SecurityException ignore) {
                // Not an error; it is OK if the threads stay live
            }
        }
    } finally {
        mainLock.unlock();
    }
}

因此，很明显，这是一种不必要的情况。但是在setCorePoolSize中没有检查，这会导致maximumPoolSize最终小于corePoolSize，并且这种情况的影响没有记录在案。

设置核心池大小

public void setCorePoolSize(int corePoolSize) {
    if (corePoolSize < 0)
        throw new IllegalArgumentException();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        int extra = this.corePoolSize - corePoolSize;
        this.corePoolSize = corePoolSize;
        if (extra < 0) {
            int n = workQueue.size(); // don't add more threads than tasks
            while (extra++ < 0 && n-- > 0 && poolSize < corePoolSize) {
                Thread t = addThread(null);
                if (t == null)
                    break;
            }
        }
        else if (extra > 0 && poolSize > corePoolSize) {
            try {
                Iterator<Worker> it = workers.iterator();
                while (it.hasNext() &&
                       extra-- > 0 &&
                       poolSize > corePoolSize &&
                       workQueue.remainingCapacity() == 0)
                    it.next().interruptIfIdle();
            } catch (SecurityException ignore) {
                // Not an error; it is OK if the threads stay live
            }
        }
    } finally {
        mainLock.unlock();
    }
}

你不认为应该有一个机制来防止这个案子的结束吗？

Answer 1

我想，你是对的，应该有这样的测试

if (corePoolSize < 0 || corePoolSize > maxPoolSize)
    throw new IllegalArgumentException();

但是您可以在调用setCorePoolSize之前轻松测试它，并在必要时调整最大池大小。即使有这样的测试，您也必须在调用setCorePoolSize之前检查最大池大小，以避免获得IllegalArgumentException...