线程池原理

    Java创建一个线程很方便，只需new Thread()就可以， 但是当有多个任务需要进行进行处理时，频繁的进行创建和启用线程同样需要系统开销，也不利于管理，于是同mysql的连接池一样，自然有对线程的管理池即线程池。

    做个比喻，线程池好比一个公司，那么线程本身就是一个个的员工，来对线程的创建和销毁进行管理，最大化的进行资源的合理调度。

    Java的线程池创建也很简单，concurrent这个并发包下有Executors可以很方便的进行四种常用线程的创建：

    newFixedThreadPool：创建固定数量的线程的线程池，可以控制最大并发数，常用于知道具体任务的数量，需要进行多线程的操作，如批量插入数据库任务，需要进行10万条数据分页，每1万条数据一页，配置一个线程处理，一共配置10个线程，进行并行批量插入，就可以使用这个线程池来进行，大大减少响应时间

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

    newCachedThreadPool: 创建可一段时间内重复利用的线程池，常用于不知道具体的任务数量，但是还需要进行并行处理的情况，如springboot @Aysnc就可以指定使用这个线程池，来进行一些埋点等的各种业务的异步处理

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

    newSingleThreadExecutor: 创建单个线程的线程池，这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去！

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    newScheduledThreadPool: 创建一个可以定时和重复执行的线程池，常用于定时任务和延时任务的执行线程池

public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

    当然线程池还可以自定义，Java只是提供了几种常用的静态线程池的创建方法，以上也已经将4种线程池的创建源码显示出来了，可以发现线程池的创建都是通过new ThreadPoolExecutor()来实现的，现在主要介绍下几个重要的参数和接口：

    首先ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，AbstractExecutorService又实现了ExecutorService接口，ExecutorService接口继承了只有一个方法execute的Executor。

 　　下面解释下一下构造器中各个参数的含义：

• corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
• maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
• keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
• unit：参数keepAliveTime的时间单位，有7种取值，分别代表一种时间的单位，秒，分，小时等：

• workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：  

ArrayBlockingQueue; 有界阻塞队列，由数组实现，需要指定数组大小
LinkedBlockingQueue; 无界阻塞队列，由链表实现，最大值是Integer的最大值 
SynchronousQueue; 这个队列不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

• threadFactory：线程工厂，主要用来创建线程；
• handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

    其中注意这几个参数都是volatile修饰的，用来保证多线程下的可见性，我们也可以根据这些参数的不同配置，来产生我们需要的线程池。

    有了线程池后，我们需要关注几个线程池的状态：

    下图表明几个状态之间的转化关系：

    接下来就是举个栗子来表明如何使用：

    ExecutorService executorService = Executors.newFixedThreadPool(15);

    在执行完上述代码后，我们其实就创建了一个有15个核心线程数量，最大也是15个线程数量，空闲线程保存时间为1分钟，采用无限阻塞队列，任务拒绝采用AbortPolicy:丢弃任务并抛出RejectedExecutionException异常的线程池。在创建后，并没有进行活跃的线程工人产生，可用线程数为0，比如接下来有10个任务进来，就会创建10个线程工人来进行工作，并且工作完不会销毁，之后又来了10个任务，之前的10个线程还没有处理完他们自己的任务，这个时候就又会创建5个线程工人来进行任务的处理，有小伙伴有疑问了，那剩下的5个任务怎么办呢，对了，还有阻塞队列，这些没有工人处理的任务会进入待办事项般的阻塞队列，先进先出，待15个工人将手头的活办完之后进行依次处理，因为阻塞队列是无界阻塞队列，因此，任务会不断的丢到这个队列中，所以，并不会创建因为队列太小，而不得已创建几个个临时工来处理，这个几个数量即在最大线程和核心线程之间的差值数量，这些临时线程的有效时间只有keepAliveTime的时间，此外在来了多个任务之后，如果队列是有界的，且任务数超过了最大能够创建的线程数，即工人不能再招了，待办事项列表也满了，这个时候公司旧不干了，抛出异常，任务拒绝策略。

    接下了是实战，结合CompletableFuture进行展示：

    简单介绍下CompletableFuture：CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法，结合线程池可以达到并发编程的目的    

package cn.chinotan;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.List;
import java.util.concurrent.*;

/**
 * @program: test
 * @description: 多线程测试
 * @author: xingcheng
 * @create: 2019-03-23 17:27
 **/
@Slf4j
public class ExecutorTest {

    @Test
    public void test() {
        ExecutorService executorService = Executors.newFixedThreadPool(15);

        CompletableFuture[] completableFutures = new CompletableFuture[15];
        List<Integer> integers = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 15; i++) {
            int finalI = i;
            CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> costMethod(finalI), executorService)
                    .whenComplete((r, e) -> {
                        if (null != e) {
                           e.printStackTrace(); 
                        } else {
                            integers.add(r);
                        }
                    });

            completableFutures[i] = integerCompletableFuture;
        }

        CompletableFuture.allOf(completableFutures).join();
        long count = integers.stream().count();
        log.info("一共处理成功：{}", count);
    }

    /**
     * 耗时的操作
     *
     * @param i
     * @return
     */
    public int costMethod(int i) {
        try {
            TimeUnit.SECONDS.sleep(5);
            log.info("耗时的操作 {}", i);
            return 1;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return 0;
        }
    }
}

    运行结果：

    可以看到15个耗时的操作很快就并行执行完成，并且还能返回执行的成功结果数

    以上就是我对线程池的理解和应用，欢迎大家关注和浏览提问，谢谢大家