害 其实银行就是一个Java线程池

银行就是一个线程池

image-20201126113618828

银行实际上就是一个Java线程池。

一次周末去银行办业务，人多排号，排的久了突然发现银行实际上和Java的线程池如此类似，可以说一模一样。于是我就展开了联想。

• 银行是个线程池
• 周末，银行七个窗口只来了两个值班的员工，那么这两个员工我们就叫做核心员工数
• 那天由于不知道什么原因，来银行办业务的人特别多，两个员工很快就忙不过来了，那么新来的人怎么办呢？只能排个号在休息区的椅子上坐着等，这一排椅子我们就叫做等待队列
• 很快，休息区也坐满了人，这个时候银行的处理业务的效率明显跟不上了，咋办呢？可以叫人会来加班（创建新的线程），由于银行只有7个窗口，所以最终只能有7个员工。最多七个柜台就叫做最大员工数

• 有了新的员工，人多了，处理业务的速度也上来了，会出现两种情况

  • 虽然银行已经满负载了，但是人还是源源不断的来银行办业务，这个时候所有的工作人员都忙着，等待区也坐满了人，那么新的人怎么办呢？工作人员可以选择让新的员工明儿，或者一会儿再来，这个让新的人什么时候来的做法，就是一种拒绝策略的选择。
  • 除了上面的情况还会有另一种情况，5个人来加班之后，效率提升，很快就把所有的业务做完了，然后银行就没有人办业务了，那么这多出来的五个人要一直在银行待着吗？肯定不是，他们会等一会儿然后回家，这个等一会儿我们可以叫做空闲等待时间

以上银行的流程和线程池的流程完全是一样的，我们只需要将

• 银行工作人员换成线程
• 办业务的人换成任务对象（Runnable）
• 休息区换成等待队列

  ......

上述的步骤就和线程池的原理，基本参数一模一样了。

说完了线程池的基本原理，接下来就是线程池常见的面试问题。

什么是线程池？有什么好处？

谈到线程池就会想到池化技术，其中最核心的思想就是把宝贵的资源放到一个池子中；每次使用都从里面获取，用完之后又放回池子供其他人使用，有点吃大锅饭的意思。

Java线程池有以下优点：

1. 线程是稀缺资源，不能频繁的创建。
2. 解耦作用；线程的创建于执行完全分开，方便维护。
3. 应当将其放入一个池子中，可以给其他任务进行复用。

创建线程池的方式

1. 通过Executors类
2. 通过ThreadPoolExecutor类

在Java中，我们可以通过Executors类创建线程池，常见的API有：

1. Executors.newCachedThreadPool()：无限线程池。
2. Executors.newFixedThreadPool(nThreads)：创建固定大小的线程池。
3. Executors.newSingleThreadExecutor()：创建单个线程的线程池。
4. Executors.newScheduledThreadPool()
5. Executors.newWorkStealingPool(int) java8新增，使用目前机器上可用的处理器作为它的并行级别

以上的这些创建线程池的方法，实际上JDK已经给我们写好的，可以拿来即用的。但是只要我们查看上述方法的源码就会发现：

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

以上方法实际上都是利用 ThreadPoolExecutor 类实现的。

所以第二种创建线程方式是自己通过 new ThreadPoolExecutor来进行创建。

Executors 有那么多创建线程池的方法，开发中用哪个比较好？

答案：一个都不用。

从《阿里巴巴Java开发手册》中可以看到

image-20200728104421665

如何通过 ThreadPoolExecutor 自定义线程池？即线程池有哪些重要的参数？

在上一个问题中，我们提到了创建线程池要通过 new ThreadPoolExecutor 的方式，那么，如何创建呢？在创建的时候，又需要哪些参数呢？

我们直接看一下 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;
    }

密密麻麻都是参数，那么这些参数都什么呢？

image-20200728104546690

大致的流程就是

1. 创建线程池之后，有任务提交给线程池，会先由 核心线程执行
2. 如果任务持续增加，corePoolSize用完并且任务队列满了，这个时候线程池会增加线程的数量，增大到最大线程数
3. 这个时候如果任务继续增加，那么由于线程数量已经达到最大线程数，等待队列也已经满了，这个时候线程池实际上是没有能力执行新的任务的，就会采用拒绝策略
4. 如果任务量下降，就会有很多线程是不需要的，无所事事，而只要这些线程空闲的时间超过空闲线程时间，就会被销毁，直到剩余线程数为corePoolSize。

通过以上参数可以就可以灵活的设置一个线程池了，示例代码如下：

/**
* 获取cpu核心数
*/
 private static int corePoolSize = Runtime.getRuntime().availableProcessors();
    /**
     * corePoolSize用于指定核心线程数量
     * maximumPoolSize指定最大线程数
     * keepAliveTime和TimeUnit指定线程空闲后的最大存活时间
     */
    public static ThreadPoolExecutor executor  = new ThreadPoolExecutor(corePoolSize, corePoolSize+1, 10l, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(1000));

线程池底层工作原理？

关于线程池的工作原理和执行流程，通过两张图来进行展示

image-20201126094135666

image-20201126094144097

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

谈谈线程池的饱和策略，也叫做拒绝策略。

所谓饱和策略就是：当等待队列已经排满，再也发不下新的任务的时候，这时，线程池的最大线程数也到了最大值，意味着线程池没有能力继续执行新任务了，这个时候再有新任务提交到线程池，如何进行处理，就是饱和（拒绝）策略

image-20201126094213570

如何合理配置一个线程池

通常我们是需要根据这批任务执行的性质来确定的。

• IO 密集型任务：由于线程并不是一直在运行，所以可以尽可能的多配置线程，比如 CPU 个数 * 2
• • IO密集型，即该任务需要大量的IO，即大量的阻塞。
  • 在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。
  • 所以IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
• CPU 密集型任务（大量复杂的运算）应当分配较少的线程，比如 CPU 个数相当的大小。CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。

当然这些都是经验值，最好的方式还是根据实际情况测试得出最佳配置。

如何关闭线程池

关闭线程池的方法有两个：shutdown()/shutdownNow()。

• shutdown() 执行后停止接受新任务，会把队列的任务执行完毕。
• shutdownNow() 也是停止接受新任务，但会中断所有的任务，将线程池状态变为 stop。

关闭线程池的代码：

long start = System.currentTimeMillis();
for (int i = 0; i <= 5; i++) {
    pool.execute(new Job());
}
pool.shutdown();
while (!pool.awaitTermination(1, TimeUnit.SECONDS)) {
    LOGGER.info("线程还在执行。。。");
}
long end = System.currentTimeMillis();
LOGGER.info("一共处理了【{}】", (end - start));

pool.awaitTermination(1, TimeUnit.SECONDS) 会每隔一秒钟检查一次是否执行完毕（状态为 TERMINATED），当从 while 循环退出时就表明线程池已经完全终止了。

❤️ 帅气的你又来看了我

如果你觉得这篇内容对你挺有有帮助的话：

1. 点赞支持下吧，让更多的人也能看到这篇内容（收藏不点赞，都是耍流氓 -_-）
2. 欢迎在留言区与我分享你的想法，也欢迎你在留言区记录你的思考过程。
3. 觉得不错的话，也可以关注 编程鹿 的个人公众号看更多文章和讲解视频（感谢大家的鼓励与支持🌹🌹🌹）