线程池原理（第一讲）

一、线程与线程池执行相同任务性能比较

1、执行100000个任务，通过线程执行代码

public static void main(String[] args) throws InterruptedException {
        Long start = System.currentTimeMillis();
        final Random random = new Random();
        final List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    list.add(random.nextInt());
                }
            };
            thread.start();
            thread.join();
        }

        System.out.println("时间：" + (System.currentTimeMillis() - start));
        System.out.println("大小：" + list.size());
    }

测试结果

2、执行100000个任务，通过线程池执行代码

public static void main(String[] args) throws InterruptedException {
        Long start = System.currentTimeMillis();
        final Random random = new Random();
        final List<Integer> list = new ArrayList<>();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100000; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    list.add(random.nextInt());
                }
            });
        }

        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("时间：" + (System.currentTimeMillis() - start));
        System.out.println("大小：" + list.size());
    }

测试结果

二、经典线程池原理

执行相同的任务量，以下三种线程池的效率对比：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService1 = Executors.newCachedThreadPool();   // 执行任务最快
        ExecutorService executorService2 = Executors.newFixedThreadPool(10); // 执行任务稍快
        ExecutorService executorService3 = Executors.newSingleThreadExecutor();   // 执行任务最慢

        for (int i = 0; i < 100; i++) {
            executorService1.execute(new MyTask(i));
            //executorService2.execute(new MyTask(i));
            //executorService3.execute(new MyTask(i));
        }
    }
}

class MyTask implements Runnable {
    int i = 0;

    public MyTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--" + i);
        try {
            Thread.sleep(1000L);   // 业务逻辑
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1、效率如下：
newCachedThreadPool() > newFixedThreadPool(10) > newSingleThreadExecutor()

2、查看源码发现上面三个线程池的创建都是底层是调用不同ThreadPoolExecutor的构造方法。

1、newCachedThreadPool可缓存线程池原理

2、newfixedThreadPool固定个数线程池原理

3、newSingleThreadExecutor单线程池原理

大型互联网公司一般不是原生的线程池，原生线程池会出现一些问题。
场景：淘宝在双十一高并发的场景会产生很多的任务。
1、如果使用newCachedThreadPool线程池创建的话，有多少个任务就会创建多少个任务线程（非核心）去执行，服务器的性能顶不住；一直创建线程，cpu可能会出现100%的情况。
2、使用newFixedThreadPool的话，核心工作线程数量有限，多余的任务堆积到队列中；一直堆积的话内存容量可能就不够，会导致内存溢出（OOM）。
3、使用newSingleThreadPool的话，类似于newFixedThreadPool的情况。

如何解决：公司一般会提前预判任务的数量级来自己实现一个ThreadPoolExecutor类供线程池使用。

三、线程池执行任务流程

1、自定义线程池（java原生线程池底层也是new ThreadPoolExecutor实现，所以我们直接new ThreadPoolExecutor来自定义）

public class ThreadPoolDemo {
    public static void main(String[] args) {
        //ExecutorService executorService1 = Executors.newCachedThreadPool();   // 执行任务最快
        //ExecutorService executorService2 = Executors.newFixedThreadPool(10); // 执行任务稍快
        //ExecutorService executorService3 = Executors.newSingleThreadExecutor();   // 执行任务最慢

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
                0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(10));
        for (int i = 0; i < 100; i++) {
            //executorService1.execute(new MyTask(i));
            //executorService2.execute(new MyTask(i));
            //executorService3.execute(new MyTask(i));
            threadPoolExecutor.execute(new MyTask(i));
        }
    }
}

class MyTask implements Runnable {
    int i = 0;

    public MyTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--" + i);
        try {
            Thread.sleep(1000L);   // 业务逻辑
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果：

2、分析
2.1 在哪个任务的时候会抛出拒绝策略信息？ （下图中序号2对其进行解释）
2.2 为什么1-9、21-30的任务先执行，10-19的任务后执行（而不是按照顺序来执行任务）？ （下图中序号3对其进行解释）

3、每个线程池在执行的时候都会调用execute方法（提交优先级规则），源码如下：

通过以上execute部分源码，画出如下对应的流程图

线程池处理任务流程图

执行任务的顺序源码及其流程图