关于线程的使用问题，使用（ThreadPoolExecutor）

深藏阁楼爱情的钟 2021-10-09 08:42 302阅读 0赞

int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
    int KEEP_ALIVE_TIME = 1;
    TimeUnit KEEP_ALIVE_TIME_UNIT = TimeUnit.SECONDS;
    BlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<Runnable>();
    ExecutorService executorService = new ThreadPoolExecutor(NUMBER_OF_CORES,
    NUMBER_OF_CORES*2, KEEP_ALIVE_TIME, KEEP_ALIVE_TIME_UNIT, taskQueue,
    new BackgroundThreadFactory(), new DefaultRejectedExecutionHandler());
    //执行任务
    executorService.execute(new Runnnable() {
    ...
    });
    
    避免使用：
    new Thread(new Runnable() {
    @Override
    public void run() {
    //操作语句
    ...
    }
    }).start();

避免使用匿名内部类。不利于线程回收，销毁，创建

建议使用线程池。 但是关于线程池创建配置，有一些疑虑：

引用别人说的话：

对于CPU密集型计算，多线程本质上是提升多核CPU的利用率，所以对于一个4核的CPU，每个核一个线程，理论上创建4个线程就可以了，再多创建线程也只是增加线程切换的成本。所以，**对于CPU密集型的计算场景，理论上“线程的数量=CPU核数”就是最合适的**。不过在工程上，**线程的数量一般会设置为“CPU核数+1”**，这样的话，当线程因为偶尔的内存页失效或其他原因导致阻塞时，这个额外的线程可以顶上，从而保证CPU的利用率。

此处附上本人设计的线程池工具类

public class ThreadPoolUtil {
        /**
         * CPU核心数
         */
        private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    
        // We want at least 2 threads and at most 4 threads in the core pool,
        // preferring to have 1 less than the CPU count to avoid saturating
        // the CPU with background work
        /**
         * 核心线程数，会一直存活，即使没有任务，线程池也会维护线程的最少数量
         */
        private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    
        /**
         * 线程池维护线程的最大数量
         */
        private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    
        /**
         * 线程池维护线程所允许的空闲时间
         */
        private static final int KEEP_ALIVE_SECONDS = 30;
    
        /**
         *线程池维护线程所允许的空闲时间单位
         */
        private static final TimeUnit UNIT = TimeUnit.SECONDS;
    
        /**
         * 线程工厂，为线程池提供创建新线程的功能
         */
        private static final ThreadFactory THREAD_FACTORY = new ThreadFactory() {
            private final AtomicInteger mCount = new AtomicInteger(1);
    
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "ChangeMax Thread #" + mCount.getAndIncrement());
            }
        };
    
        /**
         * 线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中
         */
        private static final BlockingQueue<Runnable> TASK_QUEUE = new LinkedBlockingQueue<>(128);
    
        /**
         * An {@link Executor} that can be used to execute tasks in parallel.
         */
        private static final Executor THREAD_POOL_EXECUTOR;
    
        static {
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                    CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, UNIT,
                    TASK_QUEUE, THREAD_FACTORY);
    
            //当设置allowCoreThreadTimeOut(true)时，线程池中"CORE_POOL_SIZE"线程空闲时间达到keepAliveTime也将关闭
            threadPoolExecutor.allowCoreThreadTimeOut(true);
            THREAD_POOL_EXECUTOR = threadPoolExecutor;
        }
    
        public static Executor getPool() {
            return THREAD_POOL_EXECUTOR;
        }
    
    }