从线程池入手，分析背后的实现原理

前言

java 并发编程一直是看起来高大上的东西，写写记录一下，不知道从哪里说起，就从线程池的实现来深入分析一下，可能这不是一篇概况性很强的文章，许多类和方法以前都没用过，我就从自己的角度出发，从一个线程池的实现类入手，深入分析内部的设计和实现，我们不仅仅是学习它的用法，也了解它内部的精妙的设计。

1. 线程池的实现原理

1.1 ThreadPoolExecutors

这个常用的实现类，它的继承关系如下

看起来好吓人的样子，也确实吓到了，这么多方法，但核心方法我们还是可以研究下，Executor 是它的顶级接口，定义了一个execut()方法，这是所有线程池实现类的祖先，字面意思就是执行，然后ExecutorService 接口继承了它，然后补充了一些方法，然后抽象类 AbstractExecutorService 实现接口 ExecutorService ，并且提供了一下方法的实现，我们姑且叫他模板，最后 有最后的boss 继承这个抽象类。我们发现这里源码常用的一个设计模式，就是 接口、接口继承、抽象类、实现类，其中抽象类是一个模板，这样的设计模式易域拓展。

1.1.1 研究 AbstractExecutorService 几个重要方法

方法名	说明
Future<?> submit(Runnable task)	提交执行任务，虽然返回Feture,但没有我们期望的自己的返回值
< T > Future< T > submit(Runnable task, T result)	和上面的不同，传入返回值，有我们期望的返回值
< T> Future< T> submit(Callable< T> task)	有返回值，通过 Future的get（）方法得到
invokeAny(Collection<? extends Callable< T>> tasks)	批量提交任务执行，返回第一个执行完毕的返回的结果
List<Future< T>> invokeAll(Collection<? extends Callable< T>> tasks)	批量执行任务，返回所有的结果

抽象类模板定义的这几个，然后他的子类就复用了。看代码演示

1. Future<?> submit(Runnable task) 方法：

    @Test
    public void test3() throws Exception, InterruptedException {
        ExecutorService executorService = new ThreadPoolExecutor(3,4,10000, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(5));
        Future future = executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println(future.get()); // 返回结果为空，而且这是阻滞方法，只有任务执行完毕，他才执行
    }

结果是：

pool-1-thread-1
null

2. < T> Future< T> submit(Callable< T> task) 方法：

@Test
    public void test4() throws ExecutionException, InterruptedException {
        ExecutorService executorService = new ThreadPoolExecutor(3,4,10000, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(5));
         class MyCall implements Callable<String>{
            @Override
            public String call() throws Exception {
                System.out.println(Thread.currentThread().getName());
                return "success";
            }
        }
        Future<String > future = executorService.submit(new MyCall());
        System.out.println(future.get().toString());

    }

结果：

pool-1-thread-1
success

这里是用实现CallAble接口的call方法得到的返回值，利用Runnable 也可以。

3. < T > Future< T > submit(Runnable task, T result) 方法：
   T 是作为接受返回值的传入的，如下所示

    @Test
    public void test5() throws ExecutionException, InterruptedException {
        ExecutorService executorService = new ThreadPoolExecutor(3,4,10000, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(5));

        class MyRunnable implements Runnable{
            StringBuffer str;
            public MyRunnable(StringBuffer str) {
                this.str = str;
            }
            @Override
            public void run() {
                str.append("success");
                System.out.println(Thread.currentThread().getName()+str);
            }
        }
        StringBuffer stringBuffer = new StringBuffer(); // 传入的是对象，在MyRunnable 中 是对这个对象操作
        Runnable runnable = new MyRunnable(stringBuffer);
        Future<StringBuffer> future = executorService.submit(runnable,stringBuffer); // 此处传入参数和接受结果都是一个参数对象
        System.out.println(future.get());
    }

结果

pool-1-thread-1success
success

这里需要主要，参数传入的对象和在run方法操作的是同一个对象。

4. List<Future< T>> invokeAll(Collection<? extends Callable< T>> tasks)
   当线程池需要处理的任务较多，我们可以把这些任务批量提交处理，就用到这个
   方法，只有实现Callable接口的可以这样用。
   常见使用场景：
   当从很多数据里边寻找某个资源，我们希望找到所有的，可以多个线程一起找，然后返回。

    @Test
    public void test6() throws InterruptedException, ExecutionException {
        ExecutorService executorService = new ThreadPoolExecutor(3,4,10000, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(5));

        class MyCall implements Callable<String>{
            @Override
            public String call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"执行完毕");
                return "success";
            }
        }
        List<MyCall> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {