并发编程与高并发（六）：线程调度-线程池

介绍

所谓线程池，通俗的理解就是有一个池子，里面存放着已经创建好的线程，当有任务提交给线程池执行时，池子中的某个线程会主动执行该任务。如果池子中的线程数量不够应付数量众多的任务时，则需要自动扩充新的线程到池子中，但是该数量是有限的，就好比池塘的水界限一样。当任务比较少的时候，池子中的线程能够自动回收，释放资源。为了能够异步地提交任务和缓存未被处理的任务，需要有一个任务队列。

new Thread弊端

        每次new Thread新建对象，性能较差

        线程缺乏统一管理，可能无限制的新建线程，相互竞争，有可能占用过多系统资源导致死机或OOM

        缺少更多功能，如更多执行、定期执行、线程中断

线程池的好处

        重用存在的线程，减少对象创建、消亡的开销，性能好

        可有效控制最大并发线程数，提高系统资源利用率，同时可以避免多资源竞争，避免阻塞

        提供定时执行、定期执行、单线程、并发数控制等功能

线程池原理

当一个任务提交到线程池后，大概的执行流程如下：

线程池首先会判断当前运行的线程是否小于corePoolSize。如果是，则创建一个新的工作线程来执行任务。如果都在执行任务，则进入到第二步。

判断BlockingQueue是否已经满了，如果没有满，就将线程放入BlockingQueue，否则进入到第三部。

判断maxPoolSize，如果当前线程总数小于maxPoolSize则创建一个新的工作线程，否则交给RejectedExecutionHandler来处理任务。

线程池的核心参数

corePoolSIze：核心线程数量

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务执行时最多保持多久时间终止

timeUnit：keepAliveTime的时间单位

blockingQueue：阻塞队列，存储等待执行的任务，很重要，会对线程池运行过程产生重大影响

        ArrayBlockingQueue

        基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePollSize后，再有新任务新来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

        DelayQueue

        是一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的Delayed元素

        LinkedBlockingQueue

        基于链表的无界阻塞队列（最大容量为Integer.MAX），按照FIFO排序，由于该队列近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列。因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

        PriprityBlockingQueue

        具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

        SynchronousQueue

        一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不回缓存，而是直接被调度执行该任务，如果没有可用线程则创建线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

threadFactory：线程工厂，用来创建线程

rejectHandler：当拒绝处理任务时的策略

        AbortPolicy：直接抛出异常

        DiscardPolicy：悄悄忽略掉被拒绝的任务，也不会抛出异常

        CallerRunsPolicy：任务交给线程池的调用者执行

        DiscardOldestPolicy：会把最先进入工作队列的任务出队，给新任务腾出位置

创建线程池

通过Executors创建

1.Executors.newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。

2.Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程

3.Executors.newSingleThreadExecutor：创建一个单个线程数的线程池，它可以保证先进先出的执行顺序

4.Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池

5.Executors.newSingleThreadScheduledExecutor：创建一个单线程的可以执行延迟任务的线程池

6.Executors.newWorkStealingPool：创建一个抢占式执行的线程池（任务执行顺序不确定）

通过ThreadPoolExecutor创建 

普通的线程池执行任务

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest1 {
    public static void main(String[] args) {

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2,
                4,
                5L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(finalI);
            });
        }
    }
}

带有返回值的线程池执行任务

import java.util.concurrent.*;

public class ThreadPoolExecutorTest2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 2L, TimeUnit.SECONDS, new PriorityBlockingQueue<>(3), new ThreadPoolExecutor.DiscardPolicy());
        Future<String> result = threadPool.submit(() -> {
            System.out.println("执行任务");
            Thread.sleep(2000L);
            return "done";
        });

        System.out.println(result.get());

        System.out.println("立即执行就是异步");

        threadPool.shutdown();
    }
}

配置线程池