ThreadPoolExecutor中的核心线程是什么?

问题描述

我正在查看ThreadPoolExecutor类，发现它允许指定最大池大小和核心池大小.

I was looking at the ThreadPoolExecutor class and I found that it allows to specify the maximum pool size and the core pool size.

我有点了解何时根据以下答案更改核心和最大池大小:

I understand, a little, about when to change the core and maximum pool sizes based on the answer here: When is specifying separate core and maximum pool sizes in ThreadPoolExecutor a good idea?

但是，我想知道这些核心线程"是什么.使用ThreadPoolExecutor

However, I would like to know what are these 'core threads'. I always get 0 when I use the getCorePoolSize() method of a ThreadPoolExecutor

此处为SSCCE:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

public class PoolSize {
    public static void main(String[] args) {
        // Create a cached thread pool
        ExecutorService cachedPool = Executors.newCachedThreadPool();
        // Cast the object to its class type
        ThreadPoolExecutor pool = (ThreadPoolExecutor) cachedPool;

        // Create a Callable object of anonymous class
        Callable<String> aCallable = new Callable<String>(){
            String result = "Callable done !";
            @Override
            public String call() throws Exception {
                // Print a value
                System.out.println("Callable at work !");
                // Sleep for 5 sec
                Thread.sleep(0);
                return result;
            }
        };

        // Create a Runnable object of anonymous class
        Runnable aRunnable = new Runnable(){
            @Override
            public void run() {
                try {
                    // Print a value
                    System.out.println("Runnable at work !");
                    // Sleep for 5 sec
                    Thread.sleep(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // Submit the two tasks for execution
        Future<String> callableFuture = cachedPool.submit(aCallable);
        Future<?> runnableFuture = cachedPool.submit(aRunnable);

        System.out.println("Core threads: " + pool.getCorePoolSize());
        System.out.println("Largest number of simultaneous executions: "
                                            + pool.getLargestPoolSize());
        System.out.println("Maximum number of  allowed threads: "
                                            + pool.getMaximumPoolSize());
        System.out.println("Current threads in the pool: "
                                            + pool.getPoolSize());
        System.out.println("Currently executing threads: "
                                            + pool.getTaskCount());

        pool.shutdown(); // shut down

    }
}

推荐答案

核心线程是始终最小的线程，以防万一您想将其传递给任务.如您所料，默认情况下，缓存池的核心为0.

core threads is the minimum which is always running just in case you want to pass it a task. The cached pool by default has a core of 0 as you might expect.

对于固定线程池，核心和最大值相同，即您将固定大小设置为什么.

For the fixed thread pool, the core and the maximum are the same i.e. whatever you set the fixed size to.

这篇关于ThreadPoolExecutor中的核心线程是什么?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！