ThreadPoolExecutor详细使用

值得注意的是尽量不要用，这种默认形式创建 线程池，结合自己的业务场景去做。Executors.newFixedThreadPool()
比如默认的创建 队列会让默认这种  无界限LinkedBlockingQueue队列，可以自动扩容，但是遇到高并发的场景，扩容是非常慢的。非常
浪费时间，


import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;


   

    public static void main(String[] args) throws InterruptedException {
        /**
         *    public ThreadPoolExecutor(int corePoolSize,
         *                               int maximumPoolSize,
         *                               long keepAliveTime,
         *                               TimeUnit unit,
         *                               BlockingQueue<Runnable> workQueue，
         *                               ThreadFactory threadFactory，
         *                               RejectExecutionHandler handler
         *                               ) {
         *         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         *              threadFactory, handler);
         *
         *         corePoolSize:表示线程池最小线程数量，举个例子，老板花钱雇你闲，活少的时候，
         *         不能把人都清走，要留点最少的人。
         *         maximumPoolSize：线程池最大的线程数量，当活很多的时候，最多加到maximumPoolSize人就不加了。
         *         keepAliveTime：如何判断活的忙还是闲着，某个线程在那里一段时间的空闲度，比如一个线程空闲了
         *         keepAliveTime秒 就表示闲了，且线程数大于corePoolSize 才生效，回收线程。
         *         unit：时间单位的设置
         *         workQueue：选择不同的队列，这个简单具体查一下就可以：建议高并发下指定有界限的ArrayBlockingQueue
         *         因为高并发下扩容非常耗时。
         *         threadFactory:自定义线程名称
         *         handler:自定义拒绝策略，如果线程池中所有的线程都在忙碌，且队列也满了，就会执行拒绝策略
         *         有四种可以选择：CallerRunsPolicy :提交任务的线程自己去执行该任务
         *                        AbortPolicy:默认的拒绝策略，会 throws RejectExecutionException.
         *                        DiscardPolicy:直接丢弃任务，没有任何异常抛出。
         *                        DiscardOldestPolicy:丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后
         *                        把新任务加入到工作队列。
         *
         *
         *
         */


        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                5,
                6,
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(8)
                , new JxdThreadFactory("定义你自己的线程池"),
                new ThreadPoolExecutor.AbortPolicy()
        );
        Thread thread = new Thread(() -> {
            System.out.println("执行任务》》》" + Thread.currentThread().getName());
        });
        threadPoolExecutor.execute(thread);
    }


    /**
     * 定义内部类的方式，定义线程名称
     */
    private static class JxdThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        public JxdThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                    poolNumber.getAndIncrement() +
                    "-thread-";
        }

        public JxdThreadFactory(String ThreadFactoryName) {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            namePrefix = ThreadFactoryName + "-" +
                    poolNumber.getAndIncrement() +
                    "-thread-";
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }