ThreadPoolExecutor参数说明

[ ThreadPoolExecutor的七大参数 ]

int corePoolSize： 核心线程池大小
int maximumPoolSize： 最大的线程池大小
long keepAliveTime： 存活的时间 [ 超时了没有人使用，就释放 ]
TimeUnit unit：存活的单位
BlockingQueue< Runnable > workQueue：阻塞队列
ThreadFactory threadFactory：线程工厂–创建线程的 一般不用动
RejectedExecutionHandler handler ：拒绝策略

[ ThreadPoolExecutor的四大拒绝策略 ]

AbortPolicy：满了如果还有线程进来，不处理直接抛出异常 [ java.util.concurrent.RejectedExecutionException ]
CallerRunsPolicy：哪儿来的去哪儿里,线程池不处理，最后交给了主线程处理
DiscardPolicy：队列满了不会抛出异常,任务也不会执行，直接丢弃任务
DiscardOldestPolicy： 尝试和最早的竞争,如果失败直接丢弃，成功便执行，不会抛出异常

使用

/**
     * 7大参数
     */
    public static void test(){
        //开启线程调用的 ThreadPoolExecutor

        ThreadPoolExecutor service = new ThreadPoolExecutor(2,
                                                                    5,
                                                                    3,
                                                                    TimeUnit.SECONDS,
                                                                    new LinkedBlockingDeque<>(3),
                                                                    Executors.defaultThreadFactory(),
                                                                    new ThreadPoolExecutor.DiscardOldestPolicy()
                                                            );

        /**
         *  [ ThreadPoolExecutor的七大参数 ]
         *
         * int corePoolSize,                        核心线程池大小
         * int maximumPoolSize,                     最大的线程池大小
         * long keepAliveTime,                      存活的时间 [ 超时了没有人使用，就释放 ]
         * TimeUnit unit,                           存活的单位
         * BlockingQueue<Runnable> workQueue,       阻塞队列
         * ThreadFactory threadFactory,             线程工厂--创建线程的 一般不用动
         * RejectedExecutionHandler handler         拒绝策略
         */

        /**
         *  [ ThreadPoolExecutor的四大拒绝策略 ]
         *
         * AbortPolicy                  满了如果还有线程进来，不处理直接抛出异常  [ java.util.concurrent.RejectedExecutionException ]
         * CallerRunsPolicy             哪儿来的去哪儿里,线程池不处理，最后交给了主线程处理
         * DiscardPolicy                队列满了不会抛出异常,任务也不会执行，直接丢弃任务
         * DiscardOldestPolicy          尝试和最早的竞争,如果失败直接丢弃，成功便执行，不会抛出异常
         *
         *
         */
        //获取cpu的核数
        System.err.println(Runtime.getRuntime().availableProcessors());
        try {
            for (int i = 1; i <= 9; i++) {
                service.execute(()->{
                    System.err.println(Thread.currentThread().getName()+" ok");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            service.shutdown();
        }

    }

cpu密集型 和 io密集型

cpu密集型
几核就是几，可以保证cpu的效率更高，System.err.println(Runtime.getRuntime().availableProcessors()); 获取cpu的核数

io密集型
判断你的程序中十分耗io的线程,程序里面有15个大型任务，io是非占用资源，至少要留15个线程处理io[ 一般预留30，也就是io程序的2倍 ]