多线程，高并发初步（六，线程池终极进阶）

常见面试题参考来自：https://blog.csdn.net/u013030086/article/details/84971568
前面5个博客，从最初如何创建线程、到线程的使用、多线程加锁、线程池，一步步到这最后。坚持对我来说。
主要是详细说说：1，ExecutorService接口；2，Executors帮助类；3，ThreadFactory，线程工厂
1，关于ExecutorService，前面已经从源码的角度解释过了。这里之所以拿出来，是前面的内容不够总结性：关于ExecutorService接口，他继承了，包含唯一执行方法的Executor接口，在ExecutorService接口中，定义了很多关于线程执行的状态判断方法。
2，Executors帮助类，我们来分析源码：（冗长而累赘，下面添加注释的都很重要）

public class Executors {
public static ExecutorService newFixedThreadPool(int paramInt) {  // 类型ExecutorService  固定线程池。
    return new ThreadPoolExecutor(paramInt, paramInt, 0L,				// 优点：前面讲过，以下都省略
            TimeUnit.MILLISECONDS, new LinkedBlockingQueue()); // 缺点：在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用
            //一定的系统资源
}

public static ExecutorService newWorkStealingPool(int paramInt) { // 类型ExecutorService ，需要注意是由ForkJoinPool实现的
    return new ForkJoinPool(paramInt,			
            ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
}

public static ExecutorService newWorkStealingPool() {  
    return new ForkJoinPool(Runtime.getRuntime().availableProcessors(),
            ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
}

public static ExecutorService newFixedThreadPool(int paramInt, // 同上只是多了线程工厂，后面再举例
        ThreadFactory paramThreadFactory) {
    return new ThreadPoolExecutor(paramInt, paramInt, 0L,
            TimeUnit.MILLISECONDS, new LinkedBlockingQueue(),
            paramThreadFactory);
}

public static ExecutorService newSingleThreadExecutor() { // 类型ExecutorService，单一线程池
    return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor( //我们更注重他的优点：它只会用唯一的工作线程来执行任务，保证所有任务
    //按照指定顺序(FIFO, LIFO, 优先级)执行
            1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));
}

public static ExecutorService newSingleThreadExecutor( // 同上只是多了线程工厂，后面再举例
        ThreadFactory paramThreadFactory) {
    return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(
            1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(),
            paramThreadFactory));
}

public static ExecutorService newCachedThreadPool() {  // 类型ExecutorService 
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, // 缺点：一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪
            TimeUnit.SECONDS, new SynchronousQueue()); //前面是说没有上线，其实有的，就是Integer.MAX_VALUE
}

public static ExecutorService newCachedThreadPool(  // 同上只是多了线程工厂，后面再举例
        ThreadFactory paramThreadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L,
            TimeUnit.SECONDS, new SynchronousQueue(), paramThreadFactory);
}

public static ScheduledExecutorService newSingleThreadScheduledExecutor() { // 这里需要注意，类型是ScheduledExecutorService 
    return new DelegatedScheduledExecutorService( //这个我们更关注他的优点：支持定时的以及周期性的任务执行，支持定时及周期性任务执行
            new ScheduledThreadPoolExecutor(1));
}

public static ScheduledExecutorService newSingleThreadScheduledExecutor( // 同上只是多了线程工厂，后面再举例
        ThreadFactory paramThreadFactory) {
    return new DelegatedScheduledExecutorService(
            new ScheduledThreadPoolExecutor(1, paramThreadFactory));
}

public static ScheduledExecutorService newScheduledThreadPool(int paramInt) {  //和上面差不多
    return new ScheduledThreadPoolExecutor(paramInt);
}

public static ScheduledExecutorService newScheduledThreadPool(int paramInt,
        ThreadFactory paramThreadFactory) {
    return new ScheduledThreadPoolExecutor(paramInt, paramThreadFactory);
}

public static ExecutorService unconfigurableExecutorService(
        ExecutorService paramExecutorService) {
    if (paramExecutorService == null) {
        throw new NullPointerException();
    }
    return new DelegatedExecutorService(paramExecutorService);
}

public static ScheduledExecutorService unconfigurableScheduledExecutorService(
        ScheduledExecutorService paramScheduledExecutorService) {
    if (paramScheduledExecutorService == null) {
        throw new NullPointerException();
    }
    return new DelegatedScheduledExecutorService(
            paramScheduledExecutorService);
}

public static ThreadFactory defaultThreadFactory() {  // 工厂默认优先级
    return new DefaultThreadFactory();
}

public static ThreadFactory privilegedThreadFactory() { // 线程工厂优先级设置
    return new PrivilegedThreadFactory();
}

public static  Callable callable(Runnable paramRunnable, T paramT) { //以下是Callable
    if (paramRunnable == null) {
        throw new NullPointerException();
    }
    return new RunnableAdapter(paramRunnable, paramT);
}

public static Callable