Executor与线程池：如何创建正确的线程池？_线程池一般怎么创建-CSDN博客

本文链接：https://blog.csdn.net/qq_41936805/article/details/96438692

在各大公司的面试中，线程池的题目都是比较多且比较难的，并且，线程相关的对象和其他的业务API是不相同的，区别在于一个直接操纵了操作系统，使用的是操作系统相关的API，一个单纯只占用内存。

从Java核心专栏线程相关的知识中我们也可以知道，线程的产生与销毁都会消耗一定的性能，所以要避免频繁的创建与销毁。

那么解决相关问题的方法就是，创建线程池。

概述

线程池的需求很普遍，从一般使用的池化角度去说：当你需要资源的时候就用acquire()方法来申请资源，用完之后就调用release()释放资源。但是在线程池中，是完全不同的，Java没有提供申请线程和释放线程的方法。

线程池模型：生产-消费

为什么线程池的模型和普通的池化资源不同呢，如果采用了一般模型的线程池设计，那应该是是如下：

class ThreadPool{
    //获取空闲线程
    Thread acquire() {
    }
    //释放空闲线程
    void release(Thread t) {
    }
}
    ThreadPool pool;
    Thread t1 = pool.acquire();
    //传入Runnable对象
    t1.execute(()->{
        //业务代码
    });

过程：假设我们获取到一个空闲线程T1，然后使用t1完成我们的业务。

创建线程t1
调用t1.execute()
然后传入Runnable执行基本逻辑，就像通过构造函数Thread(Runnable target)创建线程。

但是并没有execute(Runnable target)这个方法。所以线程池并不是这么设计的。

线程池最终采用的设计方式为 生产-消费

线程池的使用方式生产者，线程池本身是消费者。
可以看以下的示例代码：

package jike_Time;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

//简化的线程池，仅仅用来说明工作原理
public class MyThreadPool {
    //利用阻塞队列来实现生产者-消费者模型
    BlockingQueue<Runnable> workQueue;
    //保存内部工作线程
    List<WorkerThread> threads = new ArrayList<>();
    //构造方法
    MyThreadPool(int poolSize, BlockingQueue<Runnable> workQueue) {
        this.workQueue = workQueue;
        //创建工作线程
        for (int idx = 0; idx < poolSize; idx++) {
            WorkerThread workerThread = new WorkerThread();
            workerThread.start();
            threads.add(workerThread);
        }
    }
    //工作线程负责消费任务，并且执行任务
    class WorkerThread extends Thread {
        @Override
        public void run() {
            //循环取任务并且执行
            while (true) {
                Runnable task = null;
                try {
                    task = workQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                task.run();
            }
        }
    }

    //提交任务
    void execute(Runnable command) throws InterruptedException {
        workQueue.put(command);
    }
}



/*使用实例*/
//创建有界阻塞队列
class User {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2);
        //创建线程池
        MyThreadPool pool = new MyThreadPool(10, workQueue);
        //提交任务
        pool.execute(() ->{
            System.out.println("hello");
        });

    }
}
//output : hello

接下来看一下程序，在MyThreadPool内部，我们维护了一个阻塞队列workQueue和一组工作线程，工作线程的个数由构造函数的poolSize决定。用户通过execute()方法提交Runnable任务，execute()方法内部仅仅是添加任务到任务队列。而MyThreadPool会消费任务队列执行任务，相关的代码就是while循环。

多线程编程无法throws异常

多说一嘴，多线程编程之所以无法throws抛出异常，用最简单的话来说，多线程中一个线程中止，不会影响其他线程继续运行，所以Exception就会逃逸，在Java线程被设计出来的时候，有这样一个理念，线程自己的异常由线程自己解决，而线程的实现是在run方法内的，如果想捕获到单线程的异常，就需要在run方法内部catch，而不是在大类里面throws。
但，也并不是完全没有方法在不catch的情况下获得到线程内部的异常，java5有一个方法Thread.UncaughtExceptionHandler.uncaughtException()，可以帮助我们获取到线程内部的异常，但是很麻烦，简化之后，我们就参照正常的线程设计，去设计我们的架构就好。

如何使用java的线程池

Java的线程池中，最核心的就是ThreadPoolExecutor，此工具的构造函数十分复杂，如以下代码所示，共7个参数：

ThreadPoolExecutor(		
int	corePoolSize,		
int	maximumPoolSize,		
long	keepAliveTime,		
TimeUnit	unit,		
BlockingQueue<Runnable>	workQueue,		
ThreadFactory	threadFactory,		
RejectedExecutionHandler	handler
)

然后来一一介绍一下里面的参数：

corePoolSize ：表示线程池保有的最小线程数。一般给不太重要的业务使用。
maximumPoolSize ：表示线程池创建的最大线程数。给最繁忙的业务用，但是当业务清净下来，也会降低线程使用，但不会低于corePoolSize。
keepAliveTime & unit ：用来定义业务的空闲与繁忙，当超过keepAliveTime & unit(ms)都没有响应，就会定义为空闲，降低线程的占用。
workQueue ：工作队列，和上面示例代码的工作队列同义。
threadFactory ：通过这个参数你可以自定义如何创建线程，例如你可以给线程指定一个有意义的名字
handler：：通过这个参数你可以自定义任务的拒绝策略。如果线程池中所有的线程都在忙碌，并且工作队列也满了（前提是工作队列是有界队列），那么此时提交任务，线程池就会拒绝接收。至于拒绝的策略，你可以通过handler这个参数来指定。以下是四种拒绝方法：

CallerRunsPolicy：提交任务的线程自己去执行该任务。
AbortPolicy：默认的拒绝策略，会throws RejectedExecutionException。
DiscardPolicy：直接丢弃任务，没有任何异常抛出。
DiscardOldestPolicy：丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后把新任务加入到工作队列。

使用线程池要注意什么

因为上面提到的这些参数确实使用起来比较复杂，于是并发包就提供了一个静态并发工厂类Executors快速创建线程池，不过不建议。
原因是：Executors很多方法都是无界的LinkedBlockingQueue，无界队列想当然的会造成oom(Out of Memory)，而oom会耽误所有事情，所以建议用有界队列。

当采用了有界队列，当并发量超载的时候，就会触发RejectedExecutionException拒绝策略，此异常不会被强制catch，容易中断项目，所以要慎用，包括锁的降级同理，因此最好自定义降级策略和拒绝策略。

当使用线程池进行异常处理的时候，建议根据不同的异常，写出不同的策略。