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

并发编程与高并发（五）：线程调度-线程池 介绍

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

new Thread弊端

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

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

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

线程池的好处

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

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

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

线程池原理

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

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

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

创建新的线程直到线程数达到maximumPoolSize，如果创建一个新的工作线程将使当前运行的线程数量超过maximumPoolSize，则交给RejectedExecutionHandler来处理任务。

线程池的核心参数

corePoolSIze：核心线程数量

maximumPoolSize：线程最大线程数

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

timeUnit：keepAliveTime的时间单位

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

        ArrayBlockingQueue

        DelayQueue

        linkedBlockingQueue

        PriprityBlockingQueue

        SynchronousQueue

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 result = threadPool.submit(() -> {
            System.out.println("执行任务");
            Thread.sleep(2000L);
            return "done";
        });

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

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

        threadPool.shutdown();
    }
}

配置线程池