没用线程池的我，被上司一jio!

迷南。 2022-09-08 11:35 88阅读 0赞

大家好，我是指北君。

前天指北君的朋友小 B，他写了一个汇总的业务，用了很多的线程就是没用到线程池，被上司一顿批。那一起来看看，线程池是什么吧？

线程池是用来统一管理线程的，在 Java 中创建和销毁线程都是一件消耗资源的事情，线程池可以重复使用线程，不再频繁的创建、销毁线程。

### 初识 ###

Java 中的线程池是由 juc 即 java.util.concurrent 包来实现的，最主要的就是 ThreadPoolExecutor 类。

![fe791b6c2d6d865018ac3f834d6d81db.png][]

1.  Executor: 代表线程池的接口，有一个 execute() 方法，给一个 Runnable 类型对象就可以分配一个线程执行。
2.  ExecutorService：是 Executor 的子接口，提供了线程池的一些生命周期方法。代表了一个线程池管理器。
3.  ThreadPoolExecutor：一个线程池的实现类，可以通过调用 Executors 静态工厂方法来创建线程池并返回一个 ExecutorService 对象。

### ThredadPoolExcutor ###

看一下最常用的 ThredadPoolExcutor ,下图是 ThreadPoolExecutor 的构造函数

![3e1b8177cda19cb35131cb32758f4098.png][]

从源码中可以看出每个前三个构造函数都调用了最后一个构造函数。

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) {
        //省略代码
        }

仔细分析一下构造参数：

1.  corePoolSize：线程池里的核心线程数量，当正在运行的线程数量小于核心线程数量，就创建一个核心线程。
2.  maximumPoolSize：线程池最多能放多少个线程。
3.  keepAliveTime：线程的闲置时间，当线程池里面的线程数量大于 corePoolSize 的时候，多出来的线程在等待的时间之后会被释放掉
4.  unit：keepAliveTime 的单位
5.  workQueue：一个阻塞队列。
6.  threadFactory：通过这个工厂模式创建线程。
7.  handler：处理线程队列满了报错的。

结合线程池的参数简单的画出线程池的工作模型。

![0e3dbb70c014b27565c4409ce99075ac.png][]

当线程池中的核心线程数量 corePoolSize 满了，就会将任务先加入到任务队列 workQueue 中。

### 执行过程 ###

线程池的执行过程如下图：

1.  首先判断核心线程 corePoolSize 是不是满了，如果没有满，就执行任务，否则就进入下一步。
2.  线程池判断任务队列 workQueue 是否了，如果没有满，则将新提交的任务放入在这个任务队列里。如果任务队列满了，则进入一步。
3.  判断线程池里的线程达到了最大线程数 maximumPoolSize，如果没有，则创建一个新的线程来执行任务。如果已经满了，则交给拒绝策略来处理这个任务。

![cafe41ed751470bc42cf8bf5cbaa6958.png][]

### 常用的线程池 ###

线程池的创建需要有 7 个参数，还是比较复杂的，JVM 为我们提供了 Executors 类中多个静态工厂，生成一些常用的线程池。

#### SingleThreadExecutor ####

单线程的线程池，里面就一个核心线程数。

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

ThreadPoolExecutor 参数只有一个核心线程数和一个最大线程数，这个很少用到。它保证了所有线程的执行顺序都是按照提交到线程池的顺序执行。

public class TodoDemo implements Runnable {
    
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            for(int i = 0; i < 10; i++) {
                executorService.execute(new TodoDemo());
            }
            executorService.shutdown();
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " Running");
        }
    }

只有一个线程在跑。

![d3f192f9647f3ec42addc64a78a4276d.png][]

#### FixedThreadExecutor ####

固定数量的线程池

return new ThreadPoolExecutor(nThreads, nThreads,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>());
    }

这个线程池的特点就是线程的数量是固定的，超过这个数量的任务就得在 LinkedBlockingQueue 中排队等候。

public class TodoDemo implements Runnable {
        
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(3);
            for(int i = 0; i < 10; i++) {
                executorService.execute(new TodoDemo());
            }
            executorService.shutdown();
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " Running");
        }
    }

可以看到就算提交 100 个任务也只有 3 个线程。

![ca3d245c2082308fa7112ca97e3930c6.png][]

#### CachedThreadExecutor ####

自动回收空闲的线程

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

可以看到核心线程数量为 0， 表示不会永久保留任何的线程，最大线程的数量是 Integer.MAX\_VALUE，可以无限制的创建线程，但是当有大量线程处于空闲状态的时候，超过 60s 就会被销毁。

public class TodoDemo implements Runnable {
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newCachedThreadPool();
            for(int i = 0; i < 20; i++) {
                executorService.execute(new TodoDemo());
            }
            executorService.shutdown();
        }
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " Running");
        }
    }

虽然这个线程池可以想建多少个线程就建多少个线程，但是还是会重用已经完成任务的线程。

![855362b8769c61685c78c40580998111.png][]

一般最常用的是FixedThreadExecutor和CachedThreadExecutor。

### 线程池的回收策略 ###

在线程池中任务队列已经满了，并且线程的数量已经到了最大的数量，这个时候再加任务线程池就不再接受了。

在 ThreadPoolExecutor 里有 4 种拒绝策略，都实现了 RejectedExecutionHandler：

1.  AbortPolicy 表示抛出一个异常。
2.  DiscardPolicy 拒绝任务但是不提示。
3.  DiscardOldestPolicy 丢弃掉老的任务，执行新的任务。
4.  CallerRunsPolicy 直接调用线程处理。

### 总结 ###

线程池的作用是提高系统的性能和线程的利用率，不再需要频繁的创建和销毁线程。如果使用最简单的方式创建线程，在用户量巨大的情况下，消耗的性能是非常恐怖的，所以才有了线程池。

我是指北君，操千曲而后晓声，观千剑而后识器。感谢各位人才的：点赞、收藏和评论，我们下期更精彩！

最近又赶上跳槽的高峰期，好多粉丝，都问我要有没有最新面试题，我连日加班好多天，终于整理好了，16000+ 道，295多份，多份面试题大全，我会持续更新中，马上就会整理更多！

公众号回复【面试题】即可获取

[fe791b6c2d6d865018ac3f834d6d81db.png]: /images/20220829/2f8ecbb61aac4a388cd83830b09c7bf6.png
[3e1b8177cda19cb35131cb32758f4098.png]: /images/20220829/e96d5f4825584209af533f87b1f2f946.png
[0e3dbb70c014b27565c4409ce99075ac.png]: /images/20220829/4185c7402a1545aba67e2d0ccc4f0873.png
[cafe41ed751470bc42cf8bf5cbaa6958.png]: /images/20220829/6c5c231ae73b48b4b5289e5ec02bfec4.png
[d3f192f9647f3ec42addc64a78a4276d.png]: /images/20220829/5396982b672646f9ae7cd52e1567f61b.png
[ca3d245c2082308fa7112ca97e3930c6.png]: /images/20220829/61675178079a472bb5b3f09115af51da.png
[855362b8769c61685c78c40580998111.png]: /images/20220829/490d7ef03ae24a01b6c98e743bd2b87e.png