Java并发：搞定线程池(上)
原文地址:https://www.nowcoder.com/discuss/152050?type=0&order=0&pos=6&page=0
本文是在原文的基础+理解，想要系统学习，请看原文地址。
线程池介绍
1.1 线程池的概念
线程池(thread pool): 一种线程使用模式。线程的创建销毁是十分消耗资源的(线程创建消耗内存、线程上下文切换从消耗CPU资源)。使用线程池可以更加充分的协调应用CPU、内存、网络、I/O等系统资源。在程序启动首先创建线程，在程序启动后可以将任务直接扔到线程池中，由线程池来执行这个任务。
1.2 线程池的解决的问题
①线程创建销毁会开辟祸首虚拟机栈、本地方法栈和程序技术器等线程私有内存。
②如不加控制，线程数量在达到一定值时，由于线程上下文切换需要互斥、通信，会造成CPU资源浪费，极端情况下，系统分配的时间片都用来完成上下文切换，而没有时间去执行真正的任务。
③频繁的创建销毁线程增加并发编程的风险。
④线程池可以解决线程过多时的等待或友好的决绝服务。
1.3 线程池作用
①利用线程池管理复用线程，控制最大并发数。(避免由于先吃过多，造成完成上下文切换而真正任务不执行)
②实现任务线程队列缓存策略和拒绝机制。(优雅的处理线程过多情况)
③实现某些与实践相关的功能。(可以利用线程池完成定时任务)
④隔离线程环境。(可以将不同类型的线程池放到一台服务器，隔离不同服务，避免线程相互影响)
1.4 线程池的有点
①降低资源消耗，避免频繁的内存申请和销毁
②提高响应速度，不需要完成线程的创建，直接执行任务(前提是线程池中有空闲的线程)
③提高线程的可管理性，使用线程池可以同理管理、分配、调优和监控。
线程池创建
首先从ThreadPoolExecutor构造方法来讲自定义ThreadFactory和RejectedExecutionHandler，编写一个最简单的线程池。通过ThreadPoolExecutor的execute和addWorker两个核心方法。
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { ...... }
参数说明：
①corePoolSize：表示核心线程数：
corePoolSize=0，则任务执行完之后没有其他任务进入会销毁鲜线程池中的线程
corePoolSize>0，本地任务执行完毕后，线程池会保留corePoolSize个线程
②maximumPoolSize：表示线程池能够容纳同时执行的最大线程数
maximumPoolSize>=1，如果线程池中的线程执行，则数量大于等于1.
如果需要执行的线程数大于maximumPoolSize个线程，需要第五个参数handler来处理，缓存还是 丢弃。
③keepAliveTime：表示线程池中的线程空闲时间
当空闲时间达到keepAliveTime时，同时线程池中线程数大于信合线程数，则这个线程会被销毁。
利用这个参数，可以避免资源的浪费。
当allowCoreThreadTimeOut = true，核心线程超时也会被回收。
由源码可知，allowCoreThreadTimeOut是由volatile修饰，说明这个值变化对说有线程池中的线程可见，由于没有赋初值，默认值是false，表示核心线程超时不会被回收。
可以由方法设定，如果设置为true时，要保证线程空闲时间<=0,即表示空闲立马回收。
private volatile boolean allowCoreThreadTimeOut; public void allowCoreThreadTimeOut(boolean value) { if (value && keepAliveTime <= 0) throw new IllegalArgumentException("Core threads must have nonzero keep alive times"); allowCoreThreadTimeOut = value; }
④unit：表示时间单位
keepAliveTime的单位通常是TimeUnit.SECONDS.
⑤workQueue：表示缓存队列
当请求的线程数大于最大的线程并发数，线程会进入这个blockingQueue，阻塞保证出队入队的原子性
⑥threadFactory：线程工厂
用来生产一组相同任务的线程。
线程池的命名是通过给这个factory增加组名前缀来实现的。
虚拟机栈在分析时知道线程任务是那个线程工厂生产的。
⑦handler：表示拒绝策略的对象
当待执行的线程大于阻塞队列的最大值时，可以通过该策略处理请求，一种简单的限流保护，策略模式。
优雅的拒绝策略包括：
保存数据库进行消费填谷；在空闲的事再提取出来执行
转向某个提示页面
打印日志
2.1.1 corePoolSize 核心线程数量
线程池中应该报纸的线程数量，即使线程处于空闲期间，线程也会存在于线程池，除非设置allowCoreThreadTimeOut这个参数是false。当线程池中的线程数量少于核心线程数量，线程池会创建一个新的线程来执行这个任务，即使线程池存在空闲线程也会创建新线程。等线程池中的线程数量等于信心线程数量，这时不会再产生线程，任务会被放在队列中。
如果嗲用线程池的prestartAllCoreThreads()，线程池会提前创建并启动所有核心线程。
public int prestartAllCoreThreads() { int n = 0; while (addIfUnderCorePoolSize(null)) ++n; return n; }
2.1.2 maximumPoolsize 线程池最大线程数，同时执行的线程
线程池允许创建的最大线程数：最大线程数>=1
在固定队列长度时，最大线程数作用：用来在任务数>核心线程数+队列长度&&任务数<=最大线程数+队列长度；
如果不是固定队列这个值没有意义，任务会进入阻塞队列。
2.1.3 workQueue阻塞队列，保存任务核心线程处理不力的任务
存储待执行任务的阻塞队列，这些任务必须是Runnable对象(如果是Callable对象会在submit内部转weiRunnable对象)。
Runnable TaskQueue(任务队列)：用于保存等待执行的任务的阻塞队列，可选择下阻塞队列。
LinkedBlockingQueue：一个基于链表结构的阻塞队列，队列按照FIFO排序元素，吞吐量通常高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用这个队列。
SynchronusQueue：一个不存储元素的阻塞队列，每个插入操作必须等待另外一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常高于LinkedBlockingQueue。静态工厂方法Executors.newCachedThredPool使用这个队列。
2.1.4 threadFactory线程工厂
ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每一个创建出来的线程设置更有意义的名字。例如guava提供的ThreadFactoryBuilder快速给线程池里的线程设置有意义的名字，代码如下、
new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();
2.1.5 RejectedExecutionHandler 拒绝策略
采用了策略模式，当队列固定时，任务数>最大线程+队列长度时，这是再进来的任务需要一种策略来处理新提交的任务。默认策略AbortPolicy，表示处理新任务时抛出异常。
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
在JDK5中线程池提供了4中策略
AbortPolicy：丢弃任务，抛出RejectedExecuptionException，默认的策略
CallerRunsPolicy：只用调用者所在线程来运行任务，有反馈机制，使任务提交的速度变慢，多任务下上下文切换耗时。
DiscardOldestPolicy：若没有发生shutdown，尝试丢弃队列里最近的一个任务，并执行当前任务，丢弃任务缓存队列中最老的任务，并尝试重新提交新的任务。
DiscardPolicy：不处理，丢弃，拒绝执行，不抛异常。
也可以自定义类实现RejectedExecutionHandler接口，定制符合业务场景的拒绝策略，比如存库，日志记录等。
2.1.6 keepAliveTime 线程活动保持的时间
非核心线程线程任务执行结束后，保持多久的存活时间后被回收。
如果回收核心线程，需要设置allowCoreThreadTimeOut=true，同时keepAliveTime设置为0。
如果任务喝多，并且任务执行的时间较短，可以调大时间，提高线程的利用率。
2.1.7 TImeUnit 线程活动保持单位
指示第三个参数keepAliveTime时间的单位，常用TimeUnit.SECONDS(秒),这个类是JUC下的类，可以使用这个类来完成线程Thread.sleep(n)功能，对应TimeUnit.seconds.sleep(n).
在实际编程中使用Exceutors这个线程池里的静态工厂来创建线程池。
Executors工具类
ExecutorService的抽象类AbstractExecutorService提供submit、invokeAll等方法的实现；核心方法executr没有在这里实现，因为所有的任务都执行改方法，类似模板方式的形式，不同实现会带来不同的执行策略。
通过Executors的静态工厂可以创建三个线程洗的包装对象
①ForkJoinPool
②ThreadPoolExecutor
③ScheduledThreadPoolExecutor
3.1.1 Executors.newWorkStealingPool
JDK8引入，创建持有足够线程的线程池支持给定的并行度；
通过多个队列减少竞争；
构造方法中的CPU数量默认设置为默认的并行度。
返回ForkJoinPool对象。
public static ExecutorService newWorkStealingPool(int parallelism) { return new ForkJoinPool (parallelism, ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true); }
3.1.2 Executors.newCachedThreadPool
maxinumPoolSize最大可以取Integer的最大值，是高度可伸缩的线程池。
核心线程数0，最大线程数Integer最大值，默认空闲时间60s，如果任务数增加，再次创建新的线程处理任务。线程数达到上限出现OOM。
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }
3.1.3 Executors.newScheduledThreadPool
指定核心线程数，最大线程数是Integer最大值，没有空闲时间，阻塞队列时延迟的。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize); } public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue()); }
3.1.4 Executors.newWorkStealingPool
输入的参数即使固定线程数，核心线程和最大线程数相等，不存在空闲线程，等待时间是0.
因为使用LinkedBlockingQueue，不会因为线程数量发生OOM。
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
3.1.5 Executors.newSingleThreadExecutor
核心线程数=最大线程数=1，没有空闲时间，采用无界的LInkedBlockingQueue,不会因线程数出现OOM，但瞬间请求郭大师，会有OOM风险，相当于单线程串行执行所有任务，保证任务的提交按照提交顺序依次执行。
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }
3.2.1 线程工厂
Executors中的默认的线程工厂和拒绝策略过于简单，对用户不够友好。可以自定义，下面是默认的线程工厂，可以定制化自己的线程工厂。
static class DefaultThreadFactory implements ThreadFactory { private static final AtomicInteger poolNumber = new AtomicInteger(1); private final ThreadGroup group; private final AtomicInteger threadNumber = new AtomicInteger(1); private final String namePrefix; DefaultThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup(); namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; } public Thread newThread(Runnable r) { Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0); if (t.isDaemon()) t.setDaemon(false); if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); return t; } }
3.2.2 拒绝策略
public static class AbortPolicy implements RejectedExecutionHandler { /** * Creates an {@code AbortPolicy}. */ public AbortPolicy() { } /** * Always throws RejectedExecutionException. * * @param r the runnable task requested to be executed * @param e the executor attempting to execute this task * @throws RejectedExecutionException always */ public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString()); } }
