线程池应用

春哥思密达
102 阅读6分钟

本文已参与「新人创作礼」活动，一起开启掘金创作之路

1.线程池介绍 1.1 为什么使用线程池 过于频繁的创建/销毁线程，会影响处理效率和运行速度，消耗系统资源，降低系统稳定性，一不小心搞崩公司系统直接下岗，而使用线程池可以避免这些问题，稳住饭碗，并且可以对线程这个稀缺资源进行管理、调优与监控

1.2 线程池的优势 （1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

1.3 线程池的常用参数 线程池的真正实现类是 ThreadPoolExecutor，其构造方法有如下4种:

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); }

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler); }

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, RejectedExecutionHandler handler) { this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler); }

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue 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.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; } corePoolSize（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。 maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。 keepAliveTime（必需）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。 unit（必需）：指定 keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。 workQueue（必需）：任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。 threadFactory（可选）：线程工厂。用于指定为线程池创建新线程的方式。 handler（可选）：拒绝策略。当达到最大线程数时需要执行的饱和策略。

1.4 线程池工作原理

1.5 线程池参数 1.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 没有任何意义

1.5.2 线程工厂（threadFactory） 线程工厂指定创建线程的方式，需要实现 ThreadFactory 接口，并实现 newThread(Runnable r) 方法。该参数可以不用指定，Executors 框架已经为我们实现了一个默认的线程工厂

/**

  • The default thread factory. */ private 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; } } 1.6 拒绝策略（handler） 当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略：

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

1.7 Executors功能线程池 嫌上面使用线程池的方法太麻烦？其实Executors已经为我们封装好了 4 种常见的功能线程池，如下：

定长线程池（FixedThreadPool） 定时线程池（ScheduledThreadPool ） 可缓存线程池（CachedThreadPool） 单线程化线程池（SingleThreadExecutor）

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

// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); // 2. 创建好Runnable类线程对象 & 需执行的任务 Runnable task =new Runnable(){ public void run() { System.out.println("执行任务啦"); } }; // 3. 向线程池提交任务 fixedThreadPool.execute(task); 1.7.2 定时线程池（ScheduledThreadPool ） 特点：核心线程数量固定，非核心线程数量无限，执行完闲置 10ms 后回收，任务队列为延时阻塞队列。 应用场景：执行定时或周期性的任务。 使用示例：

// 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5 ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); // 2. 创建好Runnable类线程对象 & 需执行的任务 Runnable task =new Runnable(){ public void run() { System.out.println("执行任务啦"); } }; // 3. 向线程池提交任务 scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务 scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务 1.7.3 可缓存线程池（CachedThreadPool） 特点：无核心线程，非核心线程数量无限，执行完闲置 60s 后回收，任务队列为不存储元素的阻塞队列。 应用场景：执行大量、耗时少的任务。 使用示例：

// 1. 创建可缓存线程池对象 ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); // 2. 创建好Runnable类线程对象 & 需执行的任务 Runnable task =new Runnable(){ public void run() { System.out.println("执行任务啦"); } }; // 3. 向线程池提交任务 cachedThreadPool.execute(task); 1.7.4 单线程化线程池（SingleThreadExecutor） 特点：只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。 应用场景：不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。 使用示例：

// 1. 创建单线程化线程池 ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); // 2. 创建好Runnable类线程对象 & 需执行的任务 Runnable task =new Runnable(){ public void run() { System.out.println("执行任务啦"); } }; // 3. 向线程池提交任务 singleThreadExecutor.execute(task); 1.8 对比

1.9 总结 Executors 的 4 个功能线程池虽然方便，但现在已经不建议使用了，而是建议直接通过使用 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

其实 Executors 的 4 个功能线程有如下弊端：

1.FixedThreadPool 和 SingleThreadExecutor：主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue，可能会耗费非常大的内存，甚至 OOM。 2.CachedThreadPool 和 ScheduledThreadPool：主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。

原文链接：blog.csdn.net/u013541140/…

2.ThreadPoolExecutors方式创建线程池 2.1 线程池核心参数 corePoolSzie: 线程核心池所能容纳的线程数，满后仍有任务进入则进入阻塞队列等待

maximumPoolSize: 线程池最多所能容纳的线程数，阻塞队列也满后，仍有任务进入，会新建线程(非核心线程)来执行任务，核心池线程数+新建线程数不得超过此参数数值，否则会触发拒绝策略拒绝任务。即新建的非核心线程数最大值 = maximumPoolSize - corePoolSize

keepAliveTime: 非核心线程若超过此参数指定时间没有任务执行，则销毁线程

TimeUnit unit: 上个参数的时间单位，TimeUnit是枚举类型，有七种参数:     NANOSECONDS ： 1微毫秒 = 1秒 / 1000 * 1000 * 1000     MICROSECONDS ： 1微秒 = 1秒 / 1000 * 1000     MILLISECONDS ： 1毫秒 = 1秒 /1000     SECONDS ： 秒     MINUTES ： 分     HOURS ： 小时     DAYS ： 天

BlockingQueue workQueue: 阻塞队列，常用workQueue类型： SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大

LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize

ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误

DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

threadFactory：用于创建工作线程的工厂。 handler：拒绝策略，往线程池添加任务时，将在下面两种情况触发拒绝策略：1）线程池运行状态不是 RUNNING；2）线程池已经达到最大线程数，并且阻塞队列已满时

2.1 创建线程池示例 //创建核心线程池; 核心池容量=3; 最大线程数=10; 阻塞队列类型为ArrayBlockingQueue,容量=5; KeepAliveTime = 10ms ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10, 10L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5)); 2.3 使用线程池 2.3.1 线程服务接口 这里写一些线程接口用来测试线程和拒绝策略

package com.huachun.service;

public interface ThreadPoolService {

void threadPool(String str);

} 2.3.2 线程池使用示例 package com.huachun.service.impl;

import com.huachun.service.ThreadPoolService; import org.springframework.stereotype.Service;

import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit;

@Service public class ThreadPoolExecutorService implements ThreadPoolService {

ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10, 10L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));

@Override
public void threadPool(String str) {

// executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy()); executor.execute(() -> { System.out.println("ThreadPoolExecutor run:" + str); }); }

} 2.4 设置拒绝策略 2.4.1 创建线程实现类 package com.huachun.service.impl;

public class MyThread implements Runnable {

//region 变量
private int flag;
private int currentBlockingQueueSize;

/**
 * @param flag                     线程编号
 * @param currentBlockingQueueSize 当前阻塞队列等待的线程数量
 */
public MyThread(int flag, int currentBlockingQueueSize) {
    this.flag = flag;
    this.currentBlockingQueueSize = currentBlockingQueueSize;
}

@Override
public void run() {
    System.out.println("线程编号：" + getFlag() + "运行中----" + "当前队列中有" + currentBlockingQueueSize + "个线程");
}

//获取当前线程编号
private int getFlag() {
    return flag;
}

} 2.4.2 封装拒绝策略 package com.huachun.service.impl;

import java.util.concurrent.ThreadPoolExecutor;

public class RefusePolicy {

//region 变量
private static ThreadPoolExecutor executor;

//region 构造器
public RefusePolicy(ThreadPoolExecutor executor) {
    this.executor = executor;
}

public RefusePolicy() {
}

//region 四种策略设置
// AbortPolicy拒绝策略 --丢任务并抛出异常
public void SetAbortPolicy() {
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    System.out.println("正在使用AbortPolicy拒绝策略：");
}

// DiscardPolicy拒绝策略 --丢任务但不抛出异常
public void SetDiscardPolicy() {
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
    System.out.println("正在使用DiscardPolicy拒绝策略：");
}

// DiscardOldestPolicy拒绝策略 --丢弃最早进入队列的任务
public void SetDiscardOldestPolicy() {
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
    System.out.println("正在使用DiscardOldestPolicy拒绝策略：");
}

// CallerRunsPolicy拒绝策略 --主线程运行
public void SetCallerRunsPolicy() {
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    System.out.println("正在使用CallerRunsPolicy拒绝策略：");
}

} 2.4.3 AbortPolicy策略 package com.huachun.service.impl;

import com.huachun.service.ThreadPoolService; import org.springframework.stereotype.Service;

import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit;

@Service public class AbortPolicyService implements ThreadPoolService {

//加入线程池的线程数
int THREAD_COUNT = 30;

//创建核心线程池; 核心池容量=3; 最大线程数=10; 阻塞队列类型为ArrayBlockingQueue,容量=5; KeepAliveTime = 10ms
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10, 10L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));

@Override
public void threadPool(String str) {
    //设置策略
    //调用RefusePolicy类设置拒绝策略
    RefusePolicy refusePolicy = new RefusePolicy(executor);
    refusePolicy.SetAbortPolicy();

    try {
        //将线程加入线程池
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.execute(new MyThread(i, executor.getQueue().size()));
        }
    } catch (Exception exception) {
        System.out.println(exception);
    } finally {
        //关闭线程
        executor.shutdown();
        System.out.println("关闭");
    }
}

} 线程池最大可容纳maximumPoolSize + WorkQueue，即15个任务，我们设置了30个向线程池加入，因为任务执行可能较快，任务数设置太少不太好容易得出结果

    一开始线程池无任务，0，1，2号顺利进入核心池，核心池大小为3，3号线程进入时发现核心池满，于是3-7号线程依次进入阻塞队列，队列容量为5。然后8号任务进入时，会创建新的线程处理任务，于是8-14共7个任务会被新建的非核心线程处理，15号以后的任务进入，发现正在运行的线程数已达到maximumPoolSize,触发拒绝策略，丢弃并抛出异常，紧接着队列中的3-7也被处理。

  AbortPolicy是默认策略，抛弃多余任务，并抛出异常。

2.4.4 DiscardPolicy 与默认策略类似，只是不会抛出异常，默默丢弃任务

2.4.5 DiscardOldestPolicy 前面的都是一样，0-2号3个线程仍正常进入核心池，然后3-7进入阻塞队列，8-14号新建线程去处理，但是15进入并不会被丢弃，而是丢弃队列中的最先进入的任务，即3，然后15进入队列，同理16、17、18、19进入会丢弃队列中的4、5、6、7，然后进入队列，因此3-7被抛弃，15-19会进入队列等待被处理。

2.4.6 CallerRunsPolicy 15号及以后的任务会在进入时被拒绝，然后被回退至调用者，即主线程去执行，所以，一开始15会被主线程执行，然后等待3s后，先进入的执行完毕后，其余的也会被处理

2.4.7 总结 AbortPolicy(默认):丢弃多余任务，并抛出异常 DiscardPolicy:丢弃多余任务，但不抛出异常 DiscardOldestPolicy:丢弃最先进队列的任务，然后重新尝试加入任务 CallerRunsPolicy:不会抛弃任务，也不会抛出异常，而是将任务回退至调用者执行

原文链接：blog.csdn.net/Rain_Butter…

3.@Async方式线程 ———————————————— 版权声明：本文为CSDN博主「春卷-huachun」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：blog.csdn.net/hauchun/art…

avatar
文章
阅读
粉丝