线程池核心线程在创建后始终处于活动状态

Question

java是否保证核心池线程在ThreadPoolExecutor中始终保持活动？

我多次运行测试代码，但似乎不能保证。

我尝试了allowCoreThreadTimeOut=true和allowCoreThreadTimeOut=false。然而，行为没有改变。

这是我的测试代码。请尝试使用noOfTaskToRun 1和4这两个不同的值。

public static void main(String[] args) {
    int noOfTaskToRun = 1;
    ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 2000, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
    executor.allowCoreThreadTimeOut(false);
    List<Thread> threads = new ArrayList<Thread>();
    for(int i = 0; i<noOfTaskToRun ; i++)
        threads.add(new Thread("thread" + i) {
        public void run() {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
    for (Thread thread : threads) {
        executor.execute(thread);
    }
    System.out.println("Before executor.getActiveCount(): "+ executor.getActiveCount());
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println("After executor.getActiveCount(): "+ executor.getActiveCount());
}

我将keepAliveTime修改为2000。即使是现在，线程也在超时。

Answer 1

实际上我不能100%确定，但getActiveCount()并不是你想的那样。Docs说："返回活动执行任务的线程的大致数量。"因此，我的猜测是，空闲线程不包括在这个数字中，但仍然可以活动。您可能想要的是getPoolSize()："返回池中当前线程数。"

附加：如果你的任务睡眠5秒，并且你给所有任务5秒的超时时间，那么在超时后有多少任务会完成是非常随机的。。。

Answer 2

不，它不能保证。例如，其中一个构造函数的javadoc说：

"corePoolSize-池中要保留的线程数，即使它们处于空闲状态，除非设置了allowCoreThreadTimeOut"

显而易见的含义是，如果调用allowCoreThreadTimeOut(true)，那么即使是核心池线程也可能超时。

Answer 3

根据ThreadPoolExecutor文档，核心线程将留在池中，即使它们是空闲的，除非设置了allowCoreThreadTimeOut标志。

核心线程死亡的另一种情况是在任务执行期间抛出异常。在这种情况下，此螺纹将被替换为一个新螺纹。

Answer 4

据我所知，不会。我也看到了代码（JDK 6），似乎如果在executor的生存期内线程数少于corepool线程数，那么它就无法保证，但一旦超过了限制，就无法保证核心线程将保持活动状态。

我尝试在allowCoreThreadTimeOut=false的情况下运行。即使在那时，如果线程数超过coreThreadPoolSize，线程也会死亡。但是，如果线程数仍然小于coreThreadPoolSize，则它们仍然有效。

我认为原因在于ThreadPoolExecutor类的这两个方法。当队列为空时，FromworkerCanExit会检查coreThreadPoolSize或allowCoreThreadTimeOut的值，这就是线程超时的原因。

    Runnable getTask() {
    for (;;) {
        try {
            int state = runState;
            if (state > SHUTDOWN)
                return null;
            Runnable r;
            if (state == SHUTDOWN)  // Help drain queue
                r = workQueue.poll();
            else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
                r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
            else
                r = workQueue.take();
            if (r != null)
                return r;
            if (workerCanExit()) {
                if (runState >= SHUTDOWN) // Wake up others
                    interruptIdleWorkers();
                return null;
            }
            // Else retry
        } catch (InterruptedException ie) {
            // On interruption, re-check runState
        }
    }
}
    private boolean workerCanExit() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    boolean canExit;
    try {
        canExit = runState >= STOP ||
            workQueue.isEmpty() ||
            (allowCoreThreadTimeOut &&
             poolSize > Math.max(1, corePoolSize));
    } finally {
        mainLock.unlock();
    }
    return canExit;
}