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

java是否保证corepool线程在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());
}

publicstaticvoidmain（字符串[]args）{
int noOfTaskToRun=1；
ThreadPoolExecutor executor=新的ThreadPoolExecutor（2,42000，TimeUnit.ms，new SynchronousQueue（））；
executor.allowCoreThreadTimeOut（false）；
List threads=new ArrayList（）；
对于（int i=0；i，根据我的理解，它不会。我也看到了代码（JDK 6），似乎如果在executor的生存期内线程数小于它保证的corepoolthreads，但一旦超过了限制，就不能保证核心线程将保持活动状态

我尝试在allowCoreThreadTimeOut=false的情况下运行。即使如此，如果线程数超过coreThreadPoolSize，线程也会死亡。但是，如果线程数仍然小于coreThreadPoolSize，则它们仍然处于活动状态

我认为原因在于ThreadPoolExecutor类的这两种方法。当队列为空时，From workerCanExit会检查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;
}

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

我尝试在allowCoreThreadTimeOut=false的情况下运行。即使如此，如果线程数超过coreThreadPoolSize，线程也会死亡。但是，如果线程数仍然小于coreThreadPoolSize，则它们仍然处于活动状态

我认为原因在于ThreadPoolExecutor类的这两种方法。当队列为空时，From workerCanExit会检查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;
}

不，它不能保证这一点。例如，的javadoc说：

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

显而易见的含义是，如果调用，那么即使是核心池线程也可能超时。
不，这不能保证超时。例如，javadoc For说：

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

显而易见的含义是，如果调用，则即使核心池线程也会超时。
根据ThreadPoolExecutor文档，核心线程将留在池中，即使它们处于空闲状态，除非设置了allowCoreThreadTimeOut标志

核心线程死亡时的另一个位置是在任务执行期间引发异常。在这种情况下，此线程将替换为新线程。
根据ThreadPoolExecutor文档，核心线程将保留在池中，即使它们处于空闲状态，除非设置allowCoreThreadTimeOut标志

核心线程死亡时的另一个定位是在任务执行期间引发异常。在这种情况下，此线程将替换为新线程。
我实际上不是100%确定，但我认为
getActiveCount（）
不是您所想的。
文档说：“返回正在积极执行任务的线程的大致数量。”因此，我猜测空闲线程不包括在该数量中，但仍然可以是活动的。
您可能需要的是
getPoolSize（）
：“返回池中当前的线程数。”

另外：如果您的任务睡眠5秒，并且您给所有任务5秒的超时时间，那么在超时时间后完成任务的数量将是非常随机的…
我实际上不是100%确定，但是
getActiveCount（）
不是您所想的，我认为。
文档说：“返回正在积极执行任务的线程的大致数量。”因此，我猜测空闲线程不包括在该数量中，但仍然可以是活动的。
您可能需要的是
getPoolSize（）
：“返回池中当前的线程数。”

另外：如果您的任务睡眠5秒，并且您给所有任务都设置了5秒的超时，那么在超时后完成任务的数量将是非常随机的…
您认为什么是“corepoolthread”？如果我们将corePoolThreads定义为10，并且在运行期间有一个峰值，比如说池中有20个线程，那么在它们再次空闲并且所有超时命中后，池中应该有10个线程等待操作。（当然，AllowCoreThreamOut设置为false）至少我是这么认为的……如果在执行器的生命周期内，活动线程的数量大于coreThreadPoolSize，那么它们在完成后都会死掉。当活动线程的数量总是小于coreThreadPoolSize时，情况并非如此。你能给我们你使用的实现吗？这样我们就可以复制它了我的答案是@Braj。我认为，您看到的是错误的值。您认为什么是“corepoolthread”？如果我们将corePoolThreads定义为10，并且在运行期间，池中有一个峰值，比如说20个线程，那么在它们再次空闲并且所有超时命中后，池中应该有10个线程等待操作。（当然，AllowCorethreamOut设置为false）至少我是这么认为的……如果在执行器的生命周期内，活动线程的数量大于coreThreadPoolSize，那么它们在完成后都会死掉。当活动线程的数量始终小于