创建线程池的几种方式

newCachedThreadPool：缓存线程池

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}
说明：
1：第一个方法使用默认的线程工厂:DefaultThreadFactory
2：第二个方法使用自定义传入的线程工厂
3：核心线程数为0，即根据需要创建线程，最大值为Inter.MAX_VALUE
4：空闲超时为60秒，超过60秒空闲的线程就会从线程池中删除
5：使用SynchronousQueue队列，空队列，来多少任务，创建多少线程，可能导致cpu占满

newFixedThreadPool：固定大小线程池

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}
说明：
1：第一个方法使用默认的线程工厂:DefaultThreadFactory
2：第二个方法使用自定义传入的线程工厂
3：核心线程数等于最大线程数，只能创建固定数量的线程池，所有线程均为核心线程
4：KeepAliveTime=0,即该线程池中中的所有线程一直处于存活
5：当添加一个新任务，如果所有线程都处于工作状态，那么就会新建一个新的线程来执行该任务；
如果新建失败，那么将该任务添加到阻塞队列中进行等待
6：使用LinkedBlockingQueue阻塞队列，这个不多解释，有序队列

newScheduledThreadPool：固定大小线程池，带延迟执行和定时执行

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

说明：
1：第一个方法使用默认的线程工厂:DefaultThreadFactory
2：第二个方法使用自定义传入的线程工厂
3：返回值为ScheduledExecutorService，他也是继承了ExecutorService接口
4：使用DelayedWorkQueue作为阻塞队列

newSingleThreadExecutor：单线程线程池

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
	}
	
说明：
1：第一个方法使用默认的线程工厂:DefaultThreadFactory
2：第二个方法使用自定义传入的线程工厂
3：核心线程数和最大线程数都为1，根据需要创建一个线程
4：KeepAliveTime=0,该单线程一直存活，执行队列中的任务
5：使用LinkedBlockingQueue作为阻塞队列