public interface ExecutorService extends Executor {
    /**
     * 優(yōu)雅關(guān)閉線(xiàn)程池，之前提交的任務(wù)將被執(zhí)行，但是不會(huì)接受新的任務(wù)。
     */
    void shutdown();

    /**
     * 嘗試停止所有正在執(zhí)行的任務(wù)，停止等待任務(wù)的處理，并返回等待執(zhí)行任務(wù)的列表。
     */
    List<Runnable> shutdownNow();

    /**
     * 如果此線(xiàn)程池已關(guān)閉，則返回true.
     */
    boolean isShutdown();

    /**
     * 如果關(guān)閉后的所有任務(wù)都已完成，則返回true
     */
    boolean isTerminated();

    /**
     * 監(jiān)測(cè)ExecutorService是否已經(jīng)關(guān)閉，直到所有任務(wù)完成執(zhí)行，或超時(shí)發(fā)生，或當(dāng)前線(xiàn)程被中斷。
     */
    boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

    /**
     * 提交一個(gè)用于執(zhí)行的Callable返回任務(wù)，并返回一個(gè)Future，用于獲取Callable執(zhí)行結(jié)果。
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     * 提交可運(yùn)行任務(wù)以執(zhí)行，并返回Future，執(zhí)行結(jié)果為傳入的result
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * 提交可運(yùn)行任務(wù)以執(zhí)行，并返回Future對(duì)象，執(zhí)行結(jié)果為null
     */
    Future<?> submit(Runnable task);

    /**
     * 執(zhí)行給定的任務(wù)集合，執(zhí)行完畢后，則返回結(jié)果。
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;

    /**
     * 執(zhí)行給定的任務(wù)集合，執(zhí)行完畢或者超時(shí)后，則返回結(jié)果，其他任務(wù)終止。
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;

    /**
     * 執(zhí)行給定的任務(wù)，任意一個(gè)執(zhí)行成功則返回結(jié)果，其他任務(wù)終止。
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;

    /**
     * 執(zhí)行給定的任務(wù)，任意一個(gè)執(zhí)行成功或者超時(shí)后，則返回結(jié)果，其他任務(wù)終止
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;
}

public interface ScheduledExecutorService extends ExecutorService {

    /**
     * 創(chuàng)建并執(zhí)行一個(gè)一次性任務(wù)，過(guò)了延遲時(shí)間就會(huì)被執(zhí)行
     */
    public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

    /**
     * 創(chuàng)建并執(zhí)行一個(gè)一次性任務(wù)，過(guò)了延遲時(shí)間就會(huì)被執(zhí)行
     */
    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);

    /**
     * 創(chuàng)建并執(zhí)行一個(gè)周期性任務(wù)，過(guò)了給定的初始化延遲時(shí)間，會(huì)第一次被執(zhí)行。執(zhí)行過(guò)程中發(fā)生了異常，那么任務(wù)停止
     * 一次任務(wù)執(zhí)行時(shí)長(zhǎng)超過(guò)了周期時(shí)間，下一次任務(wù)會(huì)等到該次任務(wù)執(zhí)行結(jié)束后，立刻執(zhí)行，這也是它和scheduleWithTixedDelay的重要區(qū)別
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

    /**
     * 創(chuàng)建并執(zhí)行一個(gè)周期性任務(wù)，過(guò)了給定的初始化延遲時(shí)間，會(huì)第一次被執(zhí)行。執(zhí)行過(guò)程中發(fā)生了異常，那么任務(wù)停止
     * 一次任務(wù)執(zhí)行時(shí)長(zhǎng)超過(guò)了周期時(shí)間，下一次任務(wù)會(huì)在該次任務(wù)執(zhí)行結(jié)束的時(shí)間基礎(chǔ)上，計(jì)算執(zhí)行延時(shí)。
     * 對(duì)于超時(shí)周期的長(zhǎng)時(shí)間處理任務(wù)的不同處理方式，這是它和scheduleAtFixedRate的重要區(qū)別
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

}

public class ExecutorsUse {
    /**
     * 測(cè)試： 提交15 個(gè)執(zhí)行時(shí)間需要3秒的任務(wù),看線(xiàn)程池的狀況
     *
     * @param threadPoolExecutor 傳入不同的線(xiàn)程池，看不同的結(jié)果
     * @throws Exception
     */
    public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception {
        // 測(cè)試： 提交15個(gè)執(zhí)行時(shí)間需要3秒的任務(wù)，看超過(guò)大小的2個(gè)，對(duì)應(yīng)的處理情況
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> {
                        try {
                            System.out.println("開(kāi)始執(zhí)行：" + n);
                            Thread.sleep(3000L);
                            System.err.println("執(zhí)行結(jié)束:" + n);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
            );
            System.out.println("任務(wù)提交成功 :" + i);
        }
        // 查看線(xiàn)程數(shù)量，查看隊(duì)列等待數(shù)量
        Thread.sleep(500L);
        System.out.println("當(dāng)前線(xiàn)程池線(xiàn)程數(shù)量為：" + threadPoolExecutor.getPoolSize());
        System.out.println("當(dāng)前線(xiàn)程池等待的數(shù)量為：" + threadPoolExecutor.getQueue().size());
        // 等待15秒，查看線(xiàn)程數(shù)量和隊(duì)列數(shù)量（理論上，會(huì)被超出核心線(xiàn)程數(shù)量的線(xiàn)程自動(dòng)銷(xiāo)毀）
        Thread.sleep(15000L);
        System.out.println("當(dāng)前線(xiàn)程池線(xiàn)程數(shù)量為：" + threadPoolExecutor.getPoolSize());
        System.out.println("當(dāng)前線(xiàn)程池等待的數(shù)量為：" + threadPoolExecutor.getQueue().size());
    }

    /**
     * 1、線(xiàn)程池信息： 核心線(xiàn)程數(shù)量5，最大數(shù)量10，無(wú)界隊(duì)列，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：5秒， 指定拒絕策略
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest1() throws Exception {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>());
        testCommon(threadPoolExecutor);
        // 預(yù)計(jì)結(jié)果：線(xiàn)程池線(xiàn)程數(shù)量為：5,超出數(shù)量的任務(wù)，其他的進(jìn)入隊(duì)列中等待被執(zhí)行
    }

    /**
     * 2、 線(xiàn)程池信息： 核心線(xiàn)程數(shù)量5，最大數(shù)量10，隊(duì)列大小3，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：5秒， 指定拒絕策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest2() throws Exception {
        // 創(chuàng)建一個(gè) 核心線(xiàn)程數(shù)量為5，最大數(shù)量為10,等待隊(duì)列最大是3 的線(xiàn)程池，也就是最大容納13個(gè)任務(wù)。
        // 默認(rèn)的策略是拋出RejectedExecutionException異常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任務(wù)被拒絕執(zhí)行了");
            }
        });
        testCommon(threadPoolExecutor);
        // 預(yù)計(jì)結(jié)果：
        // 1、 5個(gè)任務(wù)直接分配線(xiàn)程開(kāi)始執(zhí)行
        // 2、 3個(gè)任務(wù)進(jìn)入等待隊(duì)列
        // 3、 隊(duì)列不夠用，臨時(shí)加開(kāi)5個(gè)線(xiàn)程來(lái)執(zhí)行任務(wù)(5秒沒(méi)活干就銷(xiāo)毀)
        // 4、 隊(duì)列和線(xiàn)程池都滿(mǎn)了，剩下2個(gè)任務(wù)，沒(méi)資源了，被拒絕執(zhí)行。
        // 5、 任務(wù)執(zhí)行，5秒后，如果無(wú)任務(wù)可執(zhí)行，銷(xiāo)毀臨時(shí)創(chuàng)建的5個(gè)線(xiàn)程
    }

    /**
     * 3、 線(xiàn)程池信息： 核心線(xiàn)程數(shù)量5，最大數(shù)量5，無(wú)界隊(duì)列，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：5秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest3() throws Exception {
        // 和Executors.newFixedThreadPool(int nThreads)一樣的
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
        testCommon(threadPoolExecutor);
        // 預(yù)計(jì)結(jié)：線(xiàn)程池線(xiàn)程數(shù)量為：5，超出數(shù)量的任務(wù)，其他的進(jìn)入隊(duì)列中等待被執(zhí)行
    }

    /**
     * 4、 線(xiàn)程池信息：
     * 核心線(xiàn)程數(shù)量0，最大數(shù)量Integer.MAX_VALUE，SynchronousQueue隊(duì)列，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：60秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest4() throws Exception {

        // SynchronousQueue，實(shí)際上它不是一個(gè)真正的隊(duì)列，因?yàn)樗粫?huì)為隊(duì)列中元素維護(hù)存儲(chǔ)空間。與其他隊(duì)列不同的是，它維護(hù)一組線(xiàn)程，這些線(xiàn)程在等待著把元素加入或移出隊(duì)列。
        // 在使用SynchronousQueue作為工作隊(duì)列的前提下，客戶(hù)端代碼向線(xiàn)程池提交任務(wù)時(shí)，
        // 而線(xiàn)程池中又沒(méi)有空閑的線(xiàn)程能夠從SynchronousQueue隊(duì)列實(shí)例中取一個(gè)任務(wù)，
        // 那么相應(yīng)的offer方法調(diào)用就會(huì)失敗（即任務(wù)沒(méi)有被存入工作隊(duì)列）。
        // 此時(shí)，ThreadPoolExecutor會(huì)新建一個(gè)新的工作者線(xiàn)程用于對(duì)這個(gè)入隊(duì)列失敗的任務(wù)進(jìn)行處理（假設(shè)此時(shí)線(xiàn)程池的大小還未達(dá)到其最大線(xiàn)程池大小maximumPoolSize）。

        // 和Executors.newCachedThreadPool()一樣的
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>());
        testCommon(threadPoolExecutor);
        // 預(yù)計(jì)結(jié)果：
        // 1、 線(xiàn)程池線(xiàn)程數(shù)量為：15，超出數(shù)量的任務(wù)，其他的進(jìn)入隊(duì)列中等待被執(zhí)行
        // 2、 所有任務(wù)執(zhí)行結(jié)束，60秒后，如果無(wú)任務(wù)可執(zhí)行，所有線(xiàn)程全部被銷(xiāo)毀，池的大小恢復(fù)為0
        Thread.sleep(60000L);
        System.out.println("60秒后，再看線(xiàn)程池中的數(shù)量：" + threadPoolExecutor.getPoolSize());
    }

    /**
     * 5、 定時(shí)執(zhí)行線(xiàn)程池信息：3秒后執(zhí)行，一次性任務(wù)，到點(diǎn)就執(zhí)行 <br/>
     * 核心線(xiàn)程數(shù)量5，最大數(shù)量Integer.MAX_VALUE，DelayedWorkQueue延時(shí)隊(duì)列，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：0秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest5() throws Exception {
        // 和Executors.newScheduledThreadPool()一樣的
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        threadPoolExecutor.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("任務(wù)被執(zhí)行，現(xiàn)在時(shí)間：" + System.currentTimeMillis());
            }
        }, 3000, TimeUnit.MILLISECONDS);
        System.out.println(
                "定時(shí)任務(wù)，提交成功，時(shí)間是：" + System.currentTimeMillis() + ", 當(dāng)前線(xiàn)程池中線(xiàn)程數(shù)量：" + threadPoolExecutor.getPoolSize());
        // 預(yù)計(jì)結(jié)果：任務(wù)在3秒后被執(zhí)行一次
    }

    /**
     * 6、 定時(shí)執(zhí)行線(xiàn)程池信息：線(xiàn)程固定數(shù)量5 ，<br/>
     * 核心線(xiàn)程數(shù)量5，最大數(shù)量Integer.MAX_VALUE，DelayedWorkQueue延時(shí)隊(duì)列，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：0秒
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest6() throws Exception {
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        // 周期性執(zhí)行某一個(gè)任務(wù)，線(xiàn)程池提供了兩種調(diào)度方式，這里單獨(dú)演示一下。測(cè)試場(chǎng)景一樣。
        // 測(cè)試場(chǎng)景：提交的任務(wù)需要3秒才能執(zhí)行完畢。看兩種不同調(diào)度方式的區(qū)別
        // 效果1： 提交后，2秒后開(kāi)始第一次執(zhí)行，之后每間隔1秒，固定執(zhí)行一次(如果發(fā)現(xiàn)上次執(zhí)行還未完畢，則等待完畢，完畢后立刻執(zhí)行)。
        // 也就是說(shuō)這個(gè)代碼中是，3秒鐘執(zhí)行一次（計(jì)算方式：每次執(zhí)行三秒，間隔時(shí)間1秒，執(zhí)行結(jié)束后馬上開(kāi)始下一次執(zhí)行，無(wú)需等待）
        threadPoolExecutor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任務(wù)-1 被執(zhí)行，現(xiàn)在時(shí)間：" + System.currentTimeMillis());
            }
        }, 2000, 1000, TimeUnit.MILLISECONDS);

        // 效果2：提交后，2秒后開(kāi)始第一次執(zhí)行，之后每間隔1秒，固定執(zhí)行一次(如果發(fā)現(xiàn)上次執(zhí)行還未完畢，則等待完畢，等上一次執(zhí)行完畢后再開(kāi)始計(jì)時(shí)，等待1秒)。
        // 也就是說(shuō)這個(gè)代碼鐘的效果看到的是：4秒執(zhí)行一次。 （計(jì)算方式：每次執(zhí)行3秒，間隔時(shí)間1秒，執(zhí)行完以后再等待1秒，所以是 3+1）
        threadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任務(wù)-2 被執(zhí)行，現(xiàn)在時(shí)間：" + System.currentTimeMillis());
            }
        }, 2000, 1000, TimeUnit.MILLISECONDS);
    }

    /**
     * 7、 終止線(xiàn)程：線(xiàn)程池信息： 核心線(xiàn)程數(shù)量5，最大數(shù)量10，隊(duì)列大小3，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：5秒， 指定拒絕策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest7() throws Exception {
        // 創(chuàng)建一個(gè) 核心線(xiàn)程數(shù)量為5，最大數(shù)量為10,等待隊(duì)列最大是3 的線(xiàn)程池，也就是最大容納13個(gè)任務(wù)。
        // 默認(rèn)的策略是拋出RejectedExecutionException異常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任務(wù)被拒絕執(zhí)行了");
            }
        });
        // 測(cè)試： 提交15個(gè)執(zhí)行時(shí)間需要3秒的任務(wù)，看超過(guò)大小的2個(gè)，對(duì)應(yīng)的處理情況
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("開(kāi)始執(zhí)行：" + n);
                        Thread.sleep(3000L);
                        System.err.println("執(zhí)行結(jié)束:" + n);
                    } catch (InterruptedException e) {
                        System.out.println("異常：" + e.getMessage());
                    }
                }
            });
            System.out.println("任務(wù)提交成功 :" + i);
        }
        // 1秒后終止線(xiàn)程池
        Thread.sleep(1000L);
        threadPoolExecutor.shutdown();
        // 再次提交提示失敗
        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("追加一個(gè)任務(wù)");
            }
        });
        // 結(jié)果分析
        // 1、 10個(gè)任務(wù)被執(zhí)行，3個(gè)任務(wù)進(jìn)入隊(duì)列等待，2個(gè)任務(wù)被拒絕執(zhí)行
        // 2、調(diào)用shutdown后，不接收新的任務(wù)，等待13任務(wù)執(zhí)行結(jié)束
        // 3、 追加的任務(wù)在線(xiàn)程池關(guān)閉后，無(wú)法再提交，會(huì)被拒絕執(zhí)行
    }

    /**
     * 8、 立刻終止線(xiàn)程：線(xiàn)程池信息： 核心線(xiàn)程數(shù)量5，最大數(shù)量10，隊(duì)列大小3，超出核心線(xiàn)程數(shù)量的線(xiàn)程存活時(shí)間：5秒， 指定拒絕策略的
     *
     * @throws Exception
     */
    private void threadPoolExecutorTest8() throws Exception {
        // 創(chuàng)建一個(gè) 核心線(xiàn)程數(shù)量為5，最大數(shù)量為10,等待隊(duì)列最大是3 的線(xiàn)程池，也就是最大容納13個(gè)任務(wù)。
        // 默認(rèn)的策略是拋出RejectedExecutionException異常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.err.println("有任務(wù)被拒絕執(zhí)行了");
            }
        });
        // 測(cè)試： 提交15個(gè)執(zhí)行時(shí)間需要3秒的任務(wù)，看超過(guò)大小的2個(gè)，對(duì)應(yīng)的處理情況
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("開(kāi)始執(zhí)行：" + n);
                        Thread.sleep(3000L);
                        System.err.println("執(zhí)行結(jié)束:" + n);
                    } catch (InterruptedException e) {
                        System.out.println("異常：" + e.getMessage());
                    }
                }
            });
            System.out.println("任務(wù)提交成功 :" + i);
        }
        // 1秒后終止線(xiàn)程池
        Thread.sleep(1000L);
        List<Runnable> shutdownNow = threadPoolExecutor.shutdownNow();
        // 再次提交提示失敗
        threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("追加一個(gè)任務(wù)");
            }
        });
        System.out.println("未結(jié)束的任務(wù)有：" + shutdownNow.size());

        // 結(jié)果分析
        // 1、 10個(gè)任務(wù)被執(zhí)行，3個(gè)任務(wù)進(jìn)入隊(duì)列等待，2個(gè)任務(wù)被拒絕執(zhí)行
        // 2、調(diào)用shutdownnow后，隊(duì)列中的3個(gè)線(xiàn)程不再執(zhí)行，10個(gè)線(xiàn)程被終止
        // 3、 追加的任務(wù)在線(xiàn)程池關(guān)閉后，無(wú)法再提交，會(huì)被拒絕執(zhí)行
    }

    public static void main(String[] args) throws Exception {
//        new ExecutorsUse().threadPoolExecutorTest1();
//        new ExecutorsUse().threadPoolExecutorTest2();
//          new ExecutorsUse().threadPoolExecutorTest3();
        new ExecutorsUse().threadPoolExecutorTest4();
//        new ExecutorsUse().threadPoolExecutorTest5();
//        new ExecutorsUse().threadPoolExecutorTest6();
//        new ExecutorsUse().threadPoolExecutorTest7();
//        new ExecutorsUse().threadPoolExecutorTest8();
    }
}