线程池的使用（newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor）

newCachedThreadPool

创建一个可扩展线程池的执行器
* 作用：用来创建一个可以无限增大的线程池。当有任务到来时，会判断当先线程池中是否有已经执行完被回收的空闲线程，有则使用，没有则创建新的线程。（空闲线程：线程如果60秒没有使用就会被任务是空闲线程并移出Cache）
* 特点：无限扩展、自动回收空闲线程、复用空闲线程
* 使用场景：在小任务量，任务时间执行短的场景下提高性能
* 注意：使用完要调用shutdown()来关闭执行器，如果不关闭，则一直等待新任务的到来。
* shutdown():调用shutdown()后不在接收新的任务，并按照已经提交的任务的顺序发起一个有序的关闭过程。如果已经关闭执行器了，则调用没有其他作用。
* 使用方式:
ExecutorService executor = Executors.newCachedThreadPool();//创建线程池执行器服务
executor.execute(task); //把Runnable交给执行器执行
executor.shutdown(); //申请关闭执行器
* 可能发生的异常：java.lang.OutOfMemoryError
* 异常原因：任务量太大，线程池不断创建新的线程，超越了内存限制

public class MyCacheThreadPool{
    public static void main(String[] arg) {
        ExecutorService executor = Executors.newCachedThreadPool();
        for(int i = 0; i < 20; i++){
            executor.execute(new Thread(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }

            }));
        }
    }

}

newFixedThreadPool

创建一个可重用的固定线程数的线程池
* 作用：任务执行开始从线程池中获取可用的线程执行任务，如果线程池中正在执行的任务达到设置的线程最大数（无可用线程），则新得任务会放到阻塞队列里等待，有可用线程时按顺序执行。
* 特点：可指定线程数、线程可重用、队列数量没有限制
* 使用场景：用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量
* 注意: 如果没有显式的关闭，则池中的线程将一直存在
* 使用方式:
ExecutorService executor = Executors.newFixedThreadPool(3);//创建线程池执行器服务
executor.execute(task); //把Runnable交给执行器执行
executor.shutdown(); //申请关闭执行器

public class MyFixedThreadPool {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for(int i = 0; i < 10; i++){
            executor.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "执行...");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            });
        }
    }   
}

newScheduledThreadPool

创建一个定长的线程池，支持定时任务、周期性任务的执行
* 作用：线程池能按时间计划来执行任务，允许用户设定计划执行任务的时间。
* 注意：newScheduledThreadPool(int corePoolSize) 参数corePoolSize设定线程池中线程的最小数目。当任务较多时，线程池可能会创建更多的工作线程来执行任务

public class MyScheduledThreadPool {
    //定时任务  
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
        executor.schedule(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "延迟3秒后运行...");

            }
        }, 3, TimeUnit.SECONDS);
    }

    //周期任务
/*  public static void main(String[] args) {
        System.out.println("任务开始，1秒后运行，每隔3秒运行一次...");
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
        executor.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "    >>>" + new Date().toLocaleString());

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

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

public class MySingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for(int i = 0; i < 10; i++){
            final int index = i;
            executor.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "执行 >>> " + index);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            });
        }
    }
}