四种ExcutorSerivce

关于和new thread的区别，不做延伸。
好处：（copy网上的解释）
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
四种ExcutorService：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1、newCachedThreadPool理解为一个无限线程池大小的线程池

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            cachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(index);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

可能会有疑问，既然无限线程池的大小，为何不直接new 一个Thread，使用线程池可以回收空闲的线程，当没有可回收的情况时，则新建线程，因此相对于每次都直接new 一个Thread，减少了新建线程的耗时，增加了资源可利用性。
（私下测试过单纯Sysout的10万个线程，时间是2400ms:460ms）
2、newFixedThreadPool 定长的线程池，线程数量超出时，等待。这个很好理解，不做解释。

ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(index);
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }

3、newSingleThreadExecutor 单线程的线程池，类似于newFixedThreadPool（1），常用场景是用于一些任务按照指定顺序执行。

    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

4、newScheduledThreadPool，定长线程池，支持定时及周期性任务。

scheduleAtFixedRate(task,delay,period,timeUtil)：从上一个任务开始执行后，period周期后执行下一个任务，但是如果上一个任务未执行完，需要等上一个任务先执行完
scheduleWithFixedDelay(task,dalay,period,timeUtil)：从上一个任务结束后，p'eriod周期执行下一个任务
schedule(task,period,timeUtil)：period秒后开始执行

    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);

        executorService.schedule(new Runnable() {

            @Override
            public void run() {
                System.out.println("yes");

            }
        }, 3, TimeUnit.SECONDS);
        // 从上一个任务开始执行后，3秒后执行下一个任务，但是如果上一个任务未执行完，需要等上一个任务先执行完
        executorService.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                System.out.println("Atfixed");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        }, 1, 3, TimeUnit.SECONDS);

        // 从上一个任务执行结束后，3秒后开始执行
        executorService.scheduleWithFixedDelay(new Runnable() {

            @Override
            public void run() {
                System.out.println("fixed");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, 1, 3, TimeUnit.SECONDS);

是不是觉得newScheduledThreadPool 和Timer有点像，从jdk1.5之后，建议使用newScheduledThreadPool取代Timer使用，因为他们功能类似，但是稳定性等方面要高于timer