06：线程池

1：线程池原理-基本概念：
    1：线程池管理器：用户管理线程池。包括创建线程池、销毁线程池，添加新任务等。
    2：工作线程：工作线程就是线程池中实际工作的线程。没有任务时：处于等待状态，有任务时：可以循环的执行任务。
    3：任务接口：每个任务都需要实现的接口。规范了任务的输入、输出等。
    4：任务队列：任务太多时，超过了线程池处理能力。将待处理的任务放到等待队列中。
2：线程池接口和实现类：
    1：接口：Executor：最上层的接口：定义了执行任务的方法：executor()
    2：接口：ExecutorService：继承了Executor接口，扩展了Callable,Future，关闭方法。
    3：接口：ScheduledExecutorService：继承了ExecutorService，怎加了定时任务相关的方法。
    4：实现类：ThreadPoolExecutor：标准的线程池实现。但是比较基础。
    5：实现类：ScheduledThreadPoolExecutor：继承了ThreadPoolExecutor，实现了ScheduledExecutorService。也就是说：在标准的线程池类基础上怎加了定时任务。

/**
 *  1：核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间5秒。
 */                                                       // 没有达到线程池最大线程数量10，而是进入了等待队列。
private static void threadPoolExecutorTest1() throws Exception{                    当前线程池线程数量为：5
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(                  当前线程池等待队列的长度：5     
            5, // 核心线程数量                                       线程结束：7
            10, // 最大线程数量                                       ...
            5, // 超出核心线程数量的线程的存活时间                            线程结束：14
            TimeUnit.SECONDS, // 单位                                   当前线程池线程数量为：5
            new LinkedBlockingQueue<Runnable>()); // 线程等待队列                   当前线程池等待队列的长度：0
    testCommon(threadPoolExecutor);                                    // 因为没有把队列占满，只有等待队列满了才会超出核心线程数量
}
/**
 *  1：等待队列长度为3，2: 指定拒绝策略。
 */ 
private static void threadPoolExecutorTest2() throws Exception{
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5, 10, 5, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(3),                             等待队列调小为3               
            new RejectedExecutionHandler() {                                        // 如果（等待队列满了 && 最大线程数量也达到了）：执行拒接策略
                @Override
                public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                    System.out.println("任务被拒绝执行。");
                }
            }
    );
    testCommon(threadPoolExecutor);
}
/**
 * 1：核心线程数量 = 最大线程数 ， 队列无界
 */
private static void threadPoolExecutorTest3()throws Exception{
    // 和线程池工具类的 Executors.newFixedThreadPool(int nThreads)实现一样。        // 和Executors.newFixedThreadPool(int nThreads)实现一样
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            5, 5, 5, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>()
    );
    testCommon(threadPoolExecutor);
}
/**
 * SynchronousQueue,实际上不是一个真正的队列，因为他不会为队列中的元素维护存储空间。他维护的是一组线程。
 * 这种线程池起初没有线程，最后执行完成后也没有线程。
 * 60秒后无用的线程就会销毁
 */
private static void threadPoolExecutorTest4() throws Exception{                // 和Executors.newCachedThreadPool() 实现一样
    // 和 Executors.newCachedThreadPool() 方法一样                       // 当无法预估需要多少线程，但是最大线程数量自己设定。不然太大了。
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0,Integer.MAX_VALUE, 60L,TimeUnit.SECONDS,   // 如果运行过程中有线程，就复用。没有就加开。     
            new SynchronousQueue<Runnable>());                            // 不工作的线程，60秒后自动销毁。
}                                                     //  注意控制最大线程数量。
/**
 * 定时执行 ： 3秒后执行，一次性执行，到时间就执行。
 *           核心线程数：5 ， 最大线程数为：Integer.MAX_VALUE
 *           DelayedWorkQueue 为延时队列，存放进去一定时间后才可以取出来。
 * @throws Exception
 */
private static void threadPoolExecutorTest5() throws Exception{                // 定时任务，延时执行一次。
    // Executors.newScheduledThreadPool()
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(5);    // 如果你的任务需要很多线程，就调多一点。
    scheduledThreadPoolExecutor.schedule(new Runnable() {
        @Override
        public void run() {
            System.out.println("任务执行");
        }
    },
    3000,
    TimeUnit.MICROSECONDS);        // 3秒之后执行
}
/**
 * 定时任务，周期性执行。（固定频率，固定延迟）
 * 固定线程数：5 核心线程数5 最大线程数Integer.MAX_VALUE 延时队列，超出核心线程数量的线程存活0秒。
 * 例如：需要定时查询数据库的任务。
 */
private static void threadPoolExecutorTest6() throws Exception{
    // 周期性执行任务有两种调度方式。
    ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
    // 第一种：固定频率：提交后：2秒后开始第一次执行，之后每间隔一秒，固定执行一次。（如果发现上次任务未完成，等待完毕后立即执行下一个任务）
    threadPoolExecutor.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
                System.out.println("如果任务执行时间超出了周期时间，下一个任务直接开始");
        }
    },2000 , 1000 ,TimeUnit.MICROSECONDS);
    // 第二种：固定延迟：提交后:两秒后开始第一次执行，之后每间隔一秒，固定执行一次。（如果发现上次任务未完毕，等上一次完毕后，再等待一秒。然后执行下一个任务）
    threadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
            System.out.println("如果任务执行时间超出了周期时间，下一个任务重新计算执行延时后再执行");
        }
    },2000,1000,TimeUnit.MICROSECONDS);
}
/**
 * 测试：提交15个执行时间为3秒的任务。并输出线程状态。
 * @param threadPoolExecutor 显示池
 */
private static void testCommon(ThreadPoolExecutor threadPoolExecutor)throws Exception{
    for (int i = 0; i < 15; i++) {
        int n = i;
        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("开始时间："+n);
                    Thread.sleep(3000L);
                    System.out.println("线程结束："+n);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println("任务提交成功"+i);
    }
    // 等待5秒后看线程池状态
    Thread.sleep(5000L);
    System.out.println("当前线程池线程数量为："+threadPoolExecutor.getPoolSize());
    System.out.println("当前线程池等待队列的长度："+threadPoolExecutor.getQueue().size());
    // 等待15秒，查看线程池状态（理论上，超出核心线程数量的线程会被销毁）
    Thread.sleep(10000L);
    System.out.println("当前线程池线程数量为："+threadPoolExecutor.getPoolSize());
    System.out.println("当前线程池等待队列的长度："+threadPoolExecutor.getQueue().size());
}