线程池创建相关

线程池的创建方式

常见的创建线程池的三种方式

1. Executors.newFixedThreadPool(int)：创建拥有指定线程数的线程池。当没有空闲线程时，任务会进入等待队列等待。
2. Executors.newSingleThreadExecutor()：创建只有一个线程数的线程池。当没有空闲线程时，任务会进入等待队列等待。
3. Executors.newCachedThreadPool()：创建可自动扩容线程数的线程池。没有空闲线程时会创建线程去执行任务，当60s内没有新任务线程会释放。

三种方式的底层实现

newFixedThreadPool

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

newSingleThreadExecutor

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

newCachedThreadPool

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

小结：

由底层代码可知，正常的创建都是通过new ThreadPoolExecutor创建的。

上述三个，实际工作中都不用，使用自定义的ThreadPoolExecutor，阿里巴巴java开发手册规定的，避免资源被耗尽的风险。

创建ThreadPoolExecutor的七大参数

源码

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

参数解释：

corePoolSize：常驻核心线程数。一般等于cpu数，Runtime.getRuntime ().availableProcessors (); 获取cpu处理器个数

maximumPoolSize：线程池的最大可执行的线程数，必须大于等于1。

keepAliveTime：指定空闲线程的等待时间，在这个等待时间内没有任务，多余空闲的线程就会自动销毁，最后只剩下核心线程。

unit：keepAliveTime的单位。

workQueue：等待队列，被提交但尚未执行的任务。

threadFactory：创建线程池的工厂，一般用默认的就行

RejectedExecutionHandler：拒绝策略，当等待队列已满，并且工作线程大于等于线程池的最大线程数时如何来拒绝请求执行Runnable的策略。

创建代码：

package com.atguigu.zp.juc;

import java.util.concurrent.*;

/**
 * @author zhangpeng
 * @create 2020/9/1 14:29
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {
//        System.out.println (Runtime.getRuntime ().availableProcessors ());  //获取cpu处理器个数

        //工作中创建线程池的方式
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor (
                2,
                5,
                3L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable> (3),  //等待队列
//                new ThreadPoolExecutr.AbortPolicy ()  //默认的执行策略  ，直接抛出RejectedExecutionException异常组织程序运行
//                new ThreadPoolExecutor.CallerRunsPolicy ()  //不抛弃任务，也不抛出异常，而是将任务回退到调用者（这里是main线程），由调用者执行，从而减低新任务的流量
//                new ThreadPoolExecutor.DiscardPolicy ()  //丢弃无法处理的任务，不抛出异常。
                new ThreadPoolExecutor.DiscardOldestPolicy ()  //抛弃队列中等待最久的任务，然后把当前任务加入队列中，尝试再次提交当前任务。
        );

        try {
            for (int i = 0; i < 9; i++) {
                poolExecutor.execute (() -> {
                    System.out.println (Thread.currentThread ().getName () + "\t办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace ();
        } finally {
            poolExecutor.shutdown ();  //关闭线程池
        }
    }

    private static void initPool() {
        //        ExecutorService executorService = Executors.newFixedThreadPool (5); //一池5个工作线程   相当于银行有5个受理窗口
        ExecutorService executorService = Executors.newSingleThreadExecutor (); //一池1个工作线程   相当于银行有1个受理窗口
//        ExecutorService executorService = Executors.newCachedThreadPool (); //一池N个工作线程   相当于银行有N个受理窗口

        try {
            for (int i = 0; i < 10; i++) {
                executorService.execute (() -> {
                    System.out.println (Thread.currentThread ().getName () + "\t办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace ();
        } finally {
            executorService.shutdown ();  //关闭线程池
        }
    }
}

线程池的主要处理流程

描述：

1、在创建了线程池后，开始等待请求。
2、当调用execute()方法添加一个请求任务时，线程池会做出如下判断：
2.1 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
2.2 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
2.3 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
2.4 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
3、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4、当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。
所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。

四种拒绝策略

new ThreadPoolExecutr.AbortPolicy ()  //默认的执行策略  ，直接抛出RejectedExecutionException异常组阻止程序运行
new ThreadPoolExecutor.CallerRunsPolicy ()  //不抛弃任务，也不抛出异常，而是将任务回退到调用者（这里是main线程），由调用者执行，从而减低新任务的流量
new ThreadPoolExecutor.DiscardPolicy ()  //丢弃无法处理的任务，不抛出异常。
new ThreadPoolExecutor.DiscardOldestPolicy ()  //抛弃队列中等待最久的任务，然后把当前任务加入队列中，尝试再次提交当前任务。

1. AbortPolicy：默认的策略，直接抛出RejectedExcecutionException异常阻止程序运行。
2. CallerRunsPolicy：”调用者运行“一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，由调用者执行，从而降低新任务的流量。
3. DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入到队列中，尝试再次提交当前任务。
4. DiscardPolicy：该策略默默地丢弃无法处理的任务，不予任何处理也不会抛出异常。如果允许任务丢失，这是最好的一种策略。