ThreadPool：线程池

1、定义

1. 缓存一定线程数量的区域。

2、作用

1. 复用、管理线程，避免新建线程/销毁线程消耗CPU资源。

3、核心参数

参数	作用
corePoolSize（核心线程数）	核心线程会一直存活
maximumPoolSize（最大线程数）	活动线程达到最大线程数，后续新任务会阻塞
keepAliveTime（闲置线程超时时长）	非核心线程闲置超过该时长将被回收（设置作用于核心线程threadPoolExecutor.allowCoreThreadTimeOut(true)）
unit（keepAliveTime 单位）	如：TimeUnit.MILLISECONDS, TimeUnit.SECONDS
workQueue（任务队列）	存放 execute() 提交的 Runnable 对象
threadFactory（线程工厂）	为线程池创建线程，Thread newThread(Runnable r)

4、工作流程

5、常用线程池

类型	线程类型	线程数量	特点	场景
定长线程池（FixedThreadPool）	核心线程	固定	1、核心线程空闲不会回收。2、所有线程处于活动状态，新的任务将处于等待状态，直到有线程空闲。3、任务队列无大小限制。4、堆积的任务可能占用大内存	控制线程最大并发数
定时线程池（ScheduledThreadPool）	核心、非核心线程	核心:固定，非核心:无限制	1、非核心线程闲置时会被回收。2、非核心线程无限制可能创建非常多线程。	执行定时/ 周期性任务
可缓存线程池（CachedThreadPool）	非核心	无限制	1、优先使用闲置线程处理任务。2、线程大小无限制。3、60 秒 回收闲置线程。4、非核心线程无限制可能创建非常多线程。	执行数量多、耗时少的任务
单线程线程池（SingleThreadExecutor）	核心线程	1个	1、任务顺序执行。2、不需要处理线程同步。3、堆积的任务可能占用大内存	单线程

6、具体使用

public class ExecutorDemo {

    public static void main(String[] args) {
        createThreadPoolExecutor();
        createFixedThreadPool();
        createScheduledThreadPool();
        createCachedThreadPool();
        createSingleThreadExecutor();
    }

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    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 BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };

    public static void createThreadPoolExecutor() {
        // 1.创建自定义线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAXIMUM_POOL_SIZE,
                KEEP_ALIVE_SECONDS,
                TimeUnit.SECONDS,
                sPoolWorkQueue,
                sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        // 2.创建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("自定义线程池-任务执行");
            }
        };
        // 3.通过线程池执行任务
        threadPoolExecutor.execute(task);
        // 4.关闭线程池
        threadPoolExecutor.shutdown();
    }

    public static void createFixedThreadPool() {
        // 1.创建定长线程池
//        public static ExecutorService newFixedThreadPool(int var0) {
//            return new ThreadPoolExecutor(var0, var0, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
//        }
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        // 2.创建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("定长线程池-任务执行");
            }
        };
        // 3.通过线程池执行任务
        fixedThreadPool.execute(task);
        // 4.关闭线程池
        fixedThreadPool.shutdown();
    }

    public static void createScheduledThreadPool() {
        // 1.创建定时线程池
//        public ScheduledThreadPoolExecutor(int var1) {
//            super(var1, 2147483647, 0L, TimeUnit.NANOSECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue());
//        }
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        // 2.创建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("定时线程池-任务执行");
            }
        };
        // 3.通过线程池执行任务,execute 立即执行，schedule 延迟1s执行,scheduleAtFixedRate 延迟1s执行之后每隔2秒执行
        // scheduledThreadPool.execute(task);
        scheduledThreadPool.schedule(task, 1000L, TimeUnit.MILLISECONDS);
        // scheduledThreadPool.scheduleAtFixedRate(task,1000L,2000L, TimeUnit.MILLISECONDS);
        // 4.关闭线程池
        scheduledThreadPool.shutdown();
    }

    public static void createCachedThreadPool() {
        // 1.创建可缓存线程池
//        public static ExecutorService newCachedThreadPool() {
//            return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());
//        }
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        // 2.创建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("可缓存线程池-任务执行");
            }
        };
        // 3.通过线程池执行任务
        cachedThreadPool.execute(task);
        // 4.关闭线程池
        cachedThreadPool.shutdown();
    }

    public static void createSingleThreadExecutor() {
        // 1.创建单线程线程池
//        public static ExecutorService newSingleThreadExecutor() {
//            return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));
//        }
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        // 2.创建任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("单线程线程池-任务执行");
            }
        };
        // 3.通过线程池执行任务
        singleThreadExecutor.execute(task);
        // 4.关闭线程池
        singleThreadExecutor.shutdown();
    }
}