java线程池浅析

不进大厂不改名二号

已于 2022-05-30 14:58:05 修改

阅读量214

点赞数 1

分类专栏： Java 文章标签： java 后端

于 2022-05-27 00:25:48 首次发布

本文链接：https://blog.csdn.net/qq_43417581/article/details/124987187

版权

Java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

前言

在多线程编程时，创建线程是十分消耗资源的，当线程创建过多时，便会引发内存溢出，因此引入了线程池技术。

一、什么是线程池？

线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

二、线程池的优势有哪些？

java中经常需要用到多线程来处理一些业务，我们非常不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程，那样势必有创建及销毁线程耗费资源、线程上下文切换问题。同时创建过多的线程也可能引发资源耗尽的风险。线程池主要就是为了解决创建线程时大量消耗资源的问题，主要优势有以下几点：

降低资源消耗：重复利用已经创建好的线程，降低了创建和销毁线程对资源的消耗。
提高响应速度：当有任务需要执行时，不需要等待线程创建，直接能够执行任务。
提高线程可管理性：对池内线程统一的进行分配和管理。

三、线程池的使用

线程池的真正实现类是 ThreadPoolExecutor，全参构造器如下所示：

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

可以看到有七大参数：

corePoolSize： 核心线程数量。线程池常驻线程数量，即使是线程空闲也不会被销毁，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
maximumPoolSize： 最大线程数量。在核心线程数的基础上可能会额外增加一些非核心线程，需要注意的是只有当workQueue队列填满时才会创建多于corePoolSize的线程(线程池总线程数不超过maxPoolSize)。
keepAliveTime： 非核心线程空闲时间，如果超过该时间，非核心线程就会被回收。
unit： keepAliveTime时间单位。
workQueue： 任务队列。当池子里的工作线程数大于corePoolSize时，这时新进来的任务会被放到该队列中。
threadFactory： 线程工厂。用于指定为线程池创建新线程的方式。
handler： 任务拒绝策略。线程池无法继续接收任务(任务队列已满且线程数达到maximunPoolSize)时的拒绝策略。

小结：当池中线程数量小于corePoolSize时，仍有任务提交到线程池，会继续创建线程；当线程数量等于corePoolSize时，仍有任务进来，新进来的任务会放入任务队列；当任务队列也填满时，才会创建多于corePoolSize的非核心线程(池中总线程数不超过maximumPoolSize)；最后当池中线程数量等于maximumPoolSize时，线程池会根据指定的拒绝策略，处理新来的任务。

四、线程池工作原理

线程池工作原理图解：
在这里插入图片描述

五、线程池参数

5.1 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现：

ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。
LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX_VALUE。
PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现 Comparable 接口也可以提供 Comparator来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
DelayQueue：类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。
SynchronousQueue：一个不存储元素的阻塞队列，消费者线程调用take() 方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用 put()方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
LinkedBlockingDeque：使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。
LinkedTransferQueue：它是ConcurrentLinkedQueue、LinkedBlockingQueue 和SynchronousQueue 的结合体，但是把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为一致，但是是无界的阻塞队列。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

5.2 线程工厂（threadFactory）

线程工厂指定线程池创建线程的方式，需要实现 ThreadFactory 接口，并实现 newThread(Runnable r) 方法。该参数可以不用指定，Executors 框架已经为我们实现了一个默认的线程工厂：Executors.defaultThreadFactory() 代码如下：

    /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

5.3 拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。 Executors 框架已经为我们实现了 4 种拒绝策略：

AbortPolicy（默认）：丢弃任务并抛出 RejectedExecutionException 异常。
CallerRunsPolicy：由调用线程处理该任务。
DiscardPolicy：丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。
DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。

六、功能线程池

Executors为我们封装了4种常用的功能线程池，具体如下：

定长线程池 FixedThreadPool
单线程线程池 SingleThreadPool
定时线程池 ScheduledThreadPool
可缓存线程池 CachedThreadPool

6.1 定长线程池 FixedThreadPool

实现源码如下：

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

特点：只有核心线程数，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：控制最大并发数。

6.2 单线程线程池 SingleThreadPool

实现源码如下：

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

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

特定：单个核心线程，无非核心线程，任务执行完直接回收，任务队列为链表结构组成的有界阻塞队列。
应用场景：单线程，不适合并发场景。当多个任务都需要访问同一个资源的时候，我们就需要对其进行控制，使得每次该资源只有一个线程在访问。这样才能保证线程安全。

6.3 定时线程池 ScheduledThreadPool

实现源码如下：

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

特点：必须指定核心线程数，可指定线程工厂，最大线程数为Integer.MAX_VALUE，任务队列为延时任务队列可做延时处理。
应用场景：执行定时 / 周期性任务。

6.4 可缓存线程池 CachedThreadPool

实现源码如下：

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

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