java的四种线程池、自定义线程池ThreadPoolExecutor以及线程池的部分源码分析

一、四个线程池的的使用：
前期准备：模拟一个多线程的环境

public class X1 {
    /**
     * 创建线程模拟实际多线程情况
     */
    public static Runnable newAndGetThread(final int n){
        return new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程"+n+"开始");
                    Thread.sleep(1000);
                    System.out.println("线程"+n+"休眠结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程"+n+"结束");
            }
        };
    }
}

第一种：使用newFixedThreadPool

	/**
     * 使用newFixedThreadPool
     * 一下子将线程放进newFixedThreadPool线程池，
     * 放的数量就是newFixedThreadPool的参数
     * 一个线程结束，再放进去新的一个线程
     */
    public void test(){
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            //execute方法会将线程池中的线程执行
            executorService.execute(X1.newAndGetThread(i));
        }
 	executorService.shutdown();
    }

这个方法会发生OOM，为什么呢？
因为他的方法是这样定义的：

  public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

可以看到 new LinkedBlockingQueue() 这个参数，Linked代表这是一个链式队列，没有指定容量，所以这是一个无界队列，当大量任务堆积在这个队列，就可能发生OOM

第二种：使用newCachedThreadPool

	/**
     * 使用newCachedThreadPool
     * 线程一波执行，然后这个池子会在60秒后自动释放资源，
     * 不用 executorService.shutdown();去释放资源
     */
    public void test(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            //execute方法会将线程池中的线程执行
            executorService.execute(X1.newAndGetThread(i));
        }
    }
}

这个也可能发生OOM，为什么呢?
还是看一下源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

这里可以看到任务队列虽然用了new SynchronousQueue()，但是我们注意到最大线程数用了 Integer.MAX_VALUE。这相当于代表线程数可以无线创建，你要不OOM，谁OOM？

第三种：使用newSingleThreadExecutor

	**
     * 使用newSingleThreadExecutor
     * 线程会一个一个的执行，需要最后时候释放资源
     */
    public void test(){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            //execute方法会将线程池中的线程执行
            executorService.execute(X1.newAndGetThread(i));
        }
        executorService.shutdown();
    }

第四种：使用newScheduledThreadPool

	/**
     * 使用newScheduledThreadPool
     * 周期性的开始线程池的处理
     */
    public void test(){
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);
        ses.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("线程开始");
                    Thread.sleep(1000);
                    System.out.println("线程休眠结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2, TimeUnit.MICROSECONDS);
    }

上面讲完了自带的四种线程池的创建，但是很显然，各有优劣，那么我们只能创建自定义的线程池了。

二、自定义线程池：

自己创建线程池，需要注意什么呢？

首先是线程数，你的是8核的CPU，那么你的核心线程数就可以是8+1，为什么是8呢，这样可以让你的8个CPU都不闲着，那为什么+1呢，因为万一有一个线程忽然终止了，那么这个+1的线程就可以立马替换上，绝不让CPU闲着。实际情况下，你设置8*2也是没问题的。

有种情况特殊：大家都知道访问资源比CPU更消耗时间，那么如果你的线程们都是在访问资源，比如文件操作或者数据库访问，那么一个线程，卡住的不是CPU的处理效率，而是资源访问的时间，这时候你的线程数可以设置的大一些。

代码：

public void test() {
        /**
         * 参数解释（按顺序）：
         * 核心线程数（可以执行的）
         * 最大线程数
         * 线程数多于核心线程数，某线程空闲时间超过这个参数的时间，这个线程会被回收
         * 上面参数的单位
         * 待处理的线程队列
         * 拒绝策略
         */
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                7,
                0L,
                TimeUnit.MICROSECONDS,
                new LinkedBlockingDeque<Runnable>(1024),
                new ThreadPoolExecutor.AbortPolicy());
        //模拟1000个线程
        for (int i = 0; i < 1000; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("线程开始");
                        Thread.sleep(1000);
                        System.out.println("当前线程名："+Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        try {
            //下面两行一起使用，优雅的关闭线程池
            executor.shutdown();
            executor.awaitTermination(1000L,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程池中任务全部结束");
    }

上面的ThreadPoolExecutor executor = new ThreadPoolExecutor(…)就是创建线程池，下面的都是在模拟线程池的使用。

三、线程池的部分源码分析：

打开ThreadPoolExecutor的源码：
开头有这样一段注释：

     * The runState provides the main lifecycle control, taking on values:
     *
     *   RUNNING:  Accept new tasks and process queued tasks
     *   SHUTDOWN: Don't accept new tasks, but process queued tasks
     *   STOP:     Don't accept new tasks, don't process queued tasks,
     *             and interrupt in-progress tasks
     *   TIDYING:  All tasks have terminated, workerCount is zero,
     *             the thread transitioning to state TIDYING
     *             will run the terminated() hook method
     *   TERMINATED: terminated() has completed

翻译过来就是：
线程池运行时有这样几个状态，如下所示：
RUNNING状态：接收新任务并处理排队的任务
SHUTDOWN状态：不接收新任务，但是处理池子中的任务
STOP状态：不接收新的任务，不处理池子中的任务
TIDYING状态：所有的任务都终止了
TERMINATED状态：池子结束了该释放了。

这个会对应下面代码中五个状态的声明：

	private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

看到这里我们心里大致有数了，线程池大概有这几种状态：

开始的时候是RUNNING，这个时候代表线程池开始工作了；
然后我们用了shutdown方法，线程池变成了SHUTDOWN状态，这个状态代表，我的线程池不能再进来新任务了，但是池子里的任务还是要执行完。
但是有时我们想立刻中止池子以及池子的任务，就会用shutdownNow方法，这个时候就会进入STOP状态，这个状态代表不接收新的任务，不处理池子中的任务，直接啥也不管，完全撂挑子；
一般来说，先进入SHUTDOWN状态，等池子里任务执行完，进入STOP状态；
当池子里没任务了，会进入TIDYING状态，这个状态没啥用，但是从SHUTDOWN或者STOP状态进入这个状态时，会调用线程池的一个生命周期钩子函数，就是terminated，这个函数可以被处理，做一些特定的业务；
最后就是terminated执行完后，会进入TERMINATED状态，线程池毁灭释放资源。

上面状态讲完，我们看到上面代码中有个“优雅关闭线程池”的两句代码：

executor.shutdown();
executor.awaitTermination(1000L,Timnit.SECONDS);

这里很多人会疑问，直接用shutdown()不好吗？
其实不是这样的，我们看一下shutdown()的源码：
有这样一段注释：

This method does not wait for previously submitted tasks to
* complete execution.  Use {@link #awaitTermination awaitTermination}
* to do that.

这是啥意思呢？
就是说：这个方法执行后，不会等待池子里的线程执行完。
举个例子：
你在餐厅吃饭，忽然餐馆歇业了，阿姨要收拾餐桌了，但是你还没吃完。
这个情境下，shutdown()就是餐馆歇业，阿姨不会等你吃完再收拾餐桌，她就是要直接收拾餐桌。
但是你执行一下awaitTermination这个方法，阿姨就会等你吃完再收拾餐桌。

这样的好处是啥呢？
就是你的池子外还有线程等着执行，但是呢，一旦只用了shutdown()方法，就会让池子里的线程自行执行，我不管了，但是池子外的线程也可以执行了，就可能发生池子外的线程比池子里的线程先执行，从而导致某些数据出错，造成程序出现问题，这个问题是很难排查的。
所以还是用一下awaitTermination方法吧，告诉阿姨等一下，等我“吃完”，你再“收拾”。