线程池一些知识解答

淡淡的烟草味﹌ 2022-11-25 13:16 144阅读 0赞

### 为什么需要线程池：线程创建、销毁 ###

线程的建立和销毁，维护一个线程池处理多任务，更加有效利用cpu。那么主要是浪费那些资源呢？我们来分析创建一个线程的过程  
上面已经提到了，创建一个线程还要调用操作系统内核API。为了更好的理解创建并启动一个线程的开销，我们需要看看 JVM 在背后帮我们做了哪些事情：

*  它为一个线程栈分配内存，该栈为每个线程方法调用保存一个栈帧  
    每一栈帧由一个局部变量数组、返回值、操作数堆栈和常量池组成  
    一些支持本机方法的 jvm 也会分配一个本机堆栈
 *  每个线程获得一个程序计数器，告诉它当前处理器执行的指令是什么
 *  将与线程相关的描述符添加到JVM内部数据结构中
 *  线程共享堆和方法区域
 *  系统创建一个与Java线程对应的本机线程  
    Java 中的线程模型是基于操作系统原生线程模型实现的，也就是说 Java 中的线程其实是基于内核线程实现的，线程的创建，析构与同步都需要进行系统调用，而系统调用需要在用户态与内核中来回切换，代价相对较高，线程的生命周期包括「线程创建时间」,「线程执行任务时间」,「线程销毁时间」，创建和销毁都需要导致系统调用。

这段描述稍稍有点抽象，用数据来说明创建一个线程（即便不干什么）需要多大空间呢？答案是大约 1M 左右。如果每个用户请求都新建线程的话，1024个线程就占用了1个G的内存，看来不对线程进行管理隐患很大，于是提出了线程池的概念。

### 线程池的使用 ###

一般我们都会用Executors来创建线程，这是一个线程池工厂类，调用各类方法可以获得相应的线程池。线程池基本都是利用ThreadPoolExecutor类来创建的，类似Executors.newFixedThreadPool的内部实现代码：

return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());  # 队列大小是 Integer.MAX_VALUE

我们根据入参顺序来刨解：

*  corePoolSize：线程的数量
 *  maximumPoolSize：最大线程数量
 *  keepAliveTime：线程存活的时间数量  
    这里要特殊说明，只有当打活跃的线程数大于corePoolSize，keepAliveTime才会起作用，线程存活的时间超过keepAliveTime就会回收线程，也就是将线程销毁。
 *  unit ：存活时间单位，是秒还是分钟还是小时
 *  workQueue：任务队列，用来存储排队执行的任务

通过参数来理解线程池的大致流程：

*  1、新来任务，当前线程数量小于corePoolSize，新建线程执行任务
 *  2、线程数量等于corePoolSize，把任务放到workQueue
 *  3、workQueue满了，线程数量小于maximumPoolSize，新建线程执行任务
 *  4、workQueue满了，线程数量等于maximumPoolSize，拒绝任务
 *  5、workQueue任务越来越少，线程不停的从里面拿任务执行。
 *  6、workQueue空了，有线程空闲并且线程数量大于corePoolSize，根据keepAliveTime来销毁多余的线程，一直到线程数量等于corePoolSize
 *  7、没有任务，当前活跃的线程数量 == corePoolSize ，不会被销毁

### Excutors工厂类 创建线程池 ###

*  newFixedThreadPool  
    corePoolSize 等于 maximumPoolSize的线程池，固定的线程数大小。  
    缺点：任务队列是LinkedBlockingQueue，最大任务数是 Integer的最大值，是个坑，积累的任务数非常多
 *  newCachedThreadPool  
    缺点：maximumPoolSize最大为 Integer.MAX\_VALUE，容易造成堆外内存溢出，SynchronousQueue入队出队必须同时传递，因为这个线程池线程最大，也不需要存储队列任务
 *  newSingleThreadExecutor  
    单个线程的线程池，只有一个线程，处理慢一点而已，但确保线程是有序处理任务。  
    缺点：LinkedBlockingQueue无边界的队列任务，处理太慢，都不会感知到。
 *  newScheduledThreadPool  
    支持定时及周期性的任务执行的线程池，maximumPoolSize的值是Integer.MAX\_VALUE；DelayedWorkQueue是无界的，因此maximumPoolSize是无效的。处理延迟主要是靠DelayedWorkQueue。  
    缺点：线程数量最大值太大，队列无界限。

阿里巴巴开发手册上：【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

因为它们或多或少的有一些问题，很容易在实际生产中引发事故，我们应该了解他们的缺点，分别来对应使用在不同的场景中，特别是自己手动创建线程池，我们应该了解这些参数该如何设置。

*  无界队列 容易导致任务不停的追加，内存不被回收，可能 OOM
 *  线程池数目无限大，容易造成堆外内存溢出
 *  有界队列：ArrayBlockingQueue：基于数组的队列，创建时需要指定大小。

拒绝策略：

*  ThreadPoolExecutor.AbortPolicy (默认的执行策略)丢弃任务，并抛出 RejectedExecutionException 异常。
 *  ThreadPoolExecutor.CallerRunsPolicy：该任务被线程池拒绝，由调用 execute 方法的线程执行该任务。
 *  ThreadPoolExecutor.DiscardOldestPolicy ：抛弃队列最前面的任务，然后重新尝试执行任务。
 *  ThreadPoolExecutor.DiscardPolicy，丢弃任务，不过也不抛出异常。

### 如何保持线程复用 ###

其实开启一个线程后，再线程的run 方法中 写一个循环，执行一个任务后就从队列中获取任务对象Worker，Worker对象是线程池定义的对象，一个Worker对象中都有一个线程，任务Worker的个数就表明线程的个数，不过代码里没有利用Worker集合的大小来做判断，而是利用了AtomicInteger对象来控制线程数量。同时为了保证避免线程的销毁，线程池稳定运行之后一般都会保证corePoolSize大小的线程是活跃的，不会主动销毁。

### 每一个任务 也都是一个Runnable对象 ###

在线程池里每一个任务也都是一个可执行的Runnable对象，在线程的run 方法中执行 task.run()方法来执行对象，这样就执行了一个任务，要记住这里不是start方法，start方法是起一个线程来执行，想当于额外的起线程来执行代码，这样就不是线程复用，所以执行run方法执行线程的内容。

### 为何设计keepAliveTime 但又不销毁全部线程 ###

主要是线程池要保证一定的线程活跃，所以不能全部销毁线程，避免频繁的创建和销毁，如果认为线程池线程一直不销毁占用系统字段，其实可以通过corePoolSize的大小来控制活跃的线程数量。

### 如何销毁线程 ###

利用阻塞队列来实现，代码如下：

private Runnable getTask() {
            boolean timedOut = false; // Did the last poll() time out?
    
            for (;;) {
                int c = ctl.get();
                int rs = runStateOf(c);
    
                // Check if queue empty only if necessary.
                if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                    decrementWorkerCount();
                    return null;
                }
    
                int wc = workerCountOf(c);
    
                // Are workers subject to culling?
                boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
    
                if ((wc > maximumPoolSize || (timed && timedOut))
                    && (wc > 1 || workQueue.isEmpty())) {
                    if (compareAndDecrementWorkerCount(c))
                        return null;
                    continue;
                }
    
                try {
                    Runnable r = timed ?
                        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                        workQueue.take();
                    if (r != null)
                        return r;
                    timedOut = true;
                } catch (InterruptedException retry) {
                    timedOut = false;
                }
            }
        }

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ; 这里面keepAliveTime 是阻塞队列等待的时间，如果超过这个时间还没有任务，就返回null，这样work对象就执行结束了，线程就执行结束，自动就销毁掉了。调用关系：

runWorker()  - - >  getTask()

### 插入任务、获取任务 ###

在超出核心线程数目后，就不再起线程，而是通过添加到阻塞队列里，暂缓任务，等有空闲线程再拉取任务。

*  插入 ：offer
 *  获取 ：take poll 两个方法

### 参考博客 ###

[线程池位运算][Link 1]  
[手撕ThreadPoolExecutor线程池源码][ThreadPoolExecutor]  
[为什么都说线程切换开销小于进程呢？][Link 2]  
[【搞定面试官】你还在用Executors来创建线程池？会有什么问题呢？][Executors]

[Link 1]: https://my.oschina.net/nimo10050/blog/4258088
[ThreadPoolExecutor]: https://juejin.im/post/6844903920511238158
[Link 2]: https://ourcoders.com/thread/show/4327/
[Executors]: https://aijishu.com/a/1060000000078349