线程池ThreadPoolExecutor使用

最新推荐文章于 2024-07-29 16:34:58 发布
最新推荐文章于 2024-07-29 16:34:58 发布
阅读量2k 收藏
点赞数
分类专栏： Java ThreadPoolExecutor 线程池 文章标签： 线程池 多线程 并发编程 java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluewait321/article/details/111086702
版权

ThreadPoolExecutor线程池使用

粗略使用ThreadPoolExecutor

ThreadPoolExecutor参数

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

corePoolSize-核心线程池大小

  • 当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建

maximumPoolSize-最大线程池大小

  • 如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务
  • PS 如果使用了无界的任务队列这个参数就没什么效果

keepAliveTime-线程最大空闲时间

线程池的工作线程空闲后，保持存活的时间

  • 如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率
  • 此参数对核心线程数的线程无作用，仅对超过核心线程大小且不超过最大线程池时创建对线程有效

TimeUnit-时间单位

指定线程最大空闲时间的单位

  • NANOSECONDS: 毫微秒 十亿分之一秒【1微秒/1000】
  • MICROSECONDS: 微秒 一百万分之一秒【1毫秒/1000】
  • MILLISECONDS: 毫秒 千分之一秒
  • SECONDS: 秒
  • MINUTES: 分钟
  • HOURS: 小时
  • DAYS: 天

blockingQueue-线程等待队列

用于保存等待执行的任务的阻塞队列

  • 可以选择以下几个阻塞队列：
  • ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序
  • LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue
  • SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue
  • PriorityBlockingQueue：一个具有优先级的无限阻塞队列

threadFactory-线程工厂

可以通过线程工厂给每个创建出来的线程做些更有意义的事情,比如设置线程线程名称和优先级等

  • 目前可以通过三个工具包创建线程工厂
  • Spring 框架提供的 CustomizableThreadFactory
  • Google guava 工具类 提供的 ThreadFactoryBuilder
  • Apache commons-lang3 提供的 BasicThreadFactory

RejectedExecutionHandler-饱和策略

当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务
这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常
PS 当使用DiscardPolicy时，如果使用线程是Future接收线程结果，如果get时不设置超时时间，则无限阻塞主线程（注意！）

  • 可以选择以下几个策略：
  • AbortPolicy：直接抛出异常
  • CallerRunsPolicy：只用调用者所在线程来运行任务
  • DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务
  • DiscardPolicy：不处理，丢弃掉
  • 自定义Reject： 实现RejectedExecutionHandler

预定义线程池

固定线程池

 	/**
     * 预定义线程池 - 固定线程池
     * 队列默认使用：LinkedBlockingQueue(一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue)
     * PS 适用场景：可用于Web服务瞬时削峰，但需注意长时间持续高峰情况造成的队列阻塞。
     * @param nThreads 线程数
     * @param threadFactory 线程工厂（可设置线程名称）
     */
    public static ExecutorService buildFixedThreadPool(int nThreads, ThreadFactory threadFactory){
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), threadFactory);
    }

无限线程池

	/**
     * 预定义线程池 - 无限线程池
     * 线程数最大为Integer.MAX_VALUE
     * 队列默认使用：SynchronousQueue(个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue)
     * 线程默认空闲时间：60s
     * PS 适用场景：快速处理大量耗时较短的任务，如Netty的NIO接受请求时，可使用CachedThreadPool
     * @param threadFactory 线程工厂（可设置线程名称）
     */
    public static ExecutorService buildCachedThreadPool(ThreadFactory threadFactory){
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>(), threadFactory);
    }

线程池使用示例

  • 线程任务
package com.panda.service.test.task.thread;

import com.alibaba.fastjson.JSONObject;
import com.panda.service.test.task.vo.OrderCheckInfo;
import com.panda.service.test.task.vo.OrderCheckResponse;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;

/**
 * 订单检查异步线程处理
 * @author w
 * @date 2020-12-09
 */
@Slf4j
public class OrderCheckThread implements Callable<OrderCheckResponse> {

    /** 订单信息 **/
    private OrderCheckInfo orderCheckInfo;

    public OrderCheckThread(OrderCheckInfo orderCheckInfo){
        this.orderCheckInfo = orderCheckInfo;
    }

    @Override
    public OrderCheckResponse call() {
        try{
            log.info("开始执行订单检查:{}", JSONObject.toJSONString(orderCheckInfo));
            return new OrderCheckResponse(true, "交易成功", orderCheckInfo.getOrderId());
        }catch (Exception e){
            log.error(e.getMessage(),e);
            return new OrderCheckResponse(false, "交易异常" + e.getMessage(), orderCheckInfo.getOrderId());
        }
    }
}
  • 构建线程池并执行线程
// 采用有界队列，长度10，LinkedBlockingQueue
// 饱和策略采用DiscardPolicy，剩下的任务丢掉不执行
ExecutorService pool = new ThreadPoolExecutor(
                    10,
                    20,
                    0L,
                    TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<>(10),
                    new ThreadPoolExecutor.AbortPolicy());


// 创建任务
OrderCheckThread thread = new OrderCheckThread(new OrderCheckInfo(System.currentTimeMillis()))

// 提交任务
Future<OrderCheckResponse> future = pool.submit(thread);

// 获取执行结果，此处会阻塞主线程等待子线程执行完成
Future<OrderCheckResponse> result = future.get();

// 关闭线程池
pool.shutdown();

完整案例

<设计思路>

  • 封装线程工厂，提供相关API，让调用者只需关系业务处理，无需了解线程执行过程;
  • 增加统一性，考虑后续统一管理

<示例>

线程配置信息
package com.panda.service.pool.config;

import java.util.concurrent.*;

/**
 * ThreadFactory Config
 * @author w
 * @date 2020-12-08
 */
public class ThreadFactoryConfig {
    /**
     * 核心线程池大小
     * 当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建
     */
    private int corePoolSize;

    /**
     * 最大线程池大小
     * 如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务
     * PS 如果使用了无界的任务队列这个参数就没什么效果
     */
    private int maximumPoolSize;

    /**
     * 线程最大空闲时间（线程池的工作线程空闲后，保持存活的时间）
     * 如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率
     */
    private long keepAliveTime;

    /**
     * 时间单位
     */
    private TimeUnit timeUnit;


    /**
     * 线程等待队列（用于保存等待执行的任务的阻塞队列）
     * 可以选择以下几个阻塞队列：
     * - ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序
     * - LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue
     * - SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue
     * - PriorityBlockingQueue：一个具有优先级的无限阻塞队列
     */
    private BlockingQueue<Runnable> blockingQueue;

    /**
     * 用于设置创建线程的工厂
     * 可以通过线程工厂给每个创建出来的线程做些更有意义的事情,比如设置线程线程名称和优先级等
     */
    private ThreadFactory threadFactory;

    /**
     * 饱和策略
     * 当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。
     * 这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常
     * 可以选择以下几个策略：
     *  - AbortPolicy：直接抛出异常
     *  - CallerRunsPolicy：只用调用者所在线程来运行任务
     *  - DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务
     *  - DiscardPolicy：不处理，丢弃掉
     *  - 自定义Reject： 实现RejectedExecutionHandler
     */
    private RejectedExecutionHandler rejectedExecutionHandler;

    public int getCorePoolSize() {
        return corePoolSize;
    }

    public void setCorePoolSize(int corePoolSize) {
        this.corePoolSize = corePoolSize;
    }

    public int getMaximumPoolSize() {
        return maximumPoolSize;
    }

    public void setMaximumPoolSize(int maximumPoolSize) {
        this.maximumPoolSize = maximumPoolSize;
    }

    public long getKeepAliveTime() {
        return keepAliveTime;
    }

    public void setKeepAliveTime(long keepAliveTime) {
        this.keepAliveTime = keepAliveTime;
    }

    public TimeUnit getTimeUnit() {
        return timeUnit;
    }

    public void setTimeUnit(TimeUnit timeUnit) {
        this.timeUnit = timeUnit;
    }

    public BlockingQueue<Runnable> getBlockingQueue() {
        return blockingQueue;
    }

    public void setBlockingQueue(BlockingQueue<Runnable> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public ThreadFactory getThreadFactory() {
        return threadFactory;
    }

    public void setThreadFactory(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
    }

    public RejectedExecutionHandler getRejectedExecutionHandler() {
        return null != rejectedExecutionHandler ? rejectedExecutionHandler : new ThreadPoolExecutor.AbortPolicy();
    }

    public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) {
        this.rejectedExecutionHandler = rejectedExecutionHandler;
    }
}
线程内置工厂
package com.panda.service.pool.factory;

import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.concurrent.ThreadFactory;

public class NameThreadFactoryBuilder {
    /**
     * 创建一个指定线程名称的线程工厂
     * @param threadName 线程名称
     * @return ThreadFactory
     */
    public static ThreadFactory buildThreadFactory(String threadName){
        return new com.google.common.util.concurrent.ThreadFactoryBuilder().setNameFormat(threadName).build();
    }

    /**
     * 创建一个指定线程名称的线程工厂
     * @param threadName 线程名称
     * @return ThreadFactory
     */
    public static ThreadFactory buildCustomizableThreadFactory(String threadName){
        return new CustomizableThreadFactory(threadName);
    }

    /**
     * 创建一个指定线程名称的线程工厂
     * @param threadName 线程名称
     * @return ThreadFactory
     */
    public static ThreadFactory buildBasicThreadFactory(String threadName){
        return new BasicThreadFactory.Builder().namingPattern(threadName).build();
    }
}
构建线程池
package com.panda.service.pool.factory;

import com.panda.service.pool.config.ThreadFactoryConfig;

import java.util.Optional;
import java.util.concurrent.*;

/**
 * 构建线程池
 * @author w
 * @date 2020-12-09
 */
public class ThreadFactoryBuilder {
    /**
     * 预定义线程池 - 固定线程池
     * 队列默认使用：LinkedBlockingQueue(一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue)
     * PS 适用场景：可用于Web服务瞬时削峰，但需注意长时间持续高峰情况造成的队列阻塞。
     * @param nThreads 线程数
     * @param threadFactory 线程工厂（可设置线程名称）
     */
    public static ExecutorService buildFixedThreadPool(int nThreads, ThreadFactory threadFactory){
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), threadFactory);
    }

    /**
     * 预定义线程池 - 无限线程池
     * 线程数最大为Integer.MAX_VALUE
     * 队列默认使用：SynchronousQueue(个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue)
     * 线程默认空闲时间：60s
     * PS 适用场景：快速处理大量耗时较短的任务，如Netty的NIO接受请求时，可使用CachedThreadPool
     * @param threadFactory 线程工厂（可设置线程名称）
     */
    public static ExecutorService buildCachedThreadPool(ThreadFactory threadFactory){
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>(), threadFactory);
    }

    /**
     * 构建自定义线程池
     * @param config 线程池配置
     */
    public static ExecutorService buildThreadPool(ThreadFactoryConfig config){
        // 检查
        Optional.ofNullable(config.getBlockingQueue()).orElseThrow(() -> new RuntimeException("BlockingQueue is null !"));
        Optional.ofNullable(config.getTimeUnit()).orElseThrow(() -> new RuntimeException("TimeUnit is null !"));

        // 构建线程池
        ExecutorService pool;
        if(null == config.getThreadFactory()){
            pool = new ThreadPoolExecutor(
                    config.getCorePoolSize(),
                    config.getMaximumPoolSize(),
                    config.getKeepAliveTime(),
                    config.getTimeUnit(),
                    config.getBlockingQueue(),
                    config.getRejectedExecutionHandler());
        }else{
            pool = new ThreadPoolExecutor(
                    config.getCorePoolSize(),
                    config.getMaximumPoolSize(),
                    config.getKeepAliveTime(),
                    config.getTimeUnit(),
                    config.getBlockingQueue(),
                    config.getThreadFactory(),
                    config.getRejectedExecutionHandler());
        }
        return pool;
    }

}
自定义饱和策略
package com.panda.service.pool.reject;

import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 饱和策略：当线程池和队列都满了，将剩余任务取消
 * PS ThreadPoolExecutor.DiscardPolicy饱和策略，如果使用Future会无法停止线程，永远在等待结果
 * @author w
 * @date 2020-12-09
 */
public class DiscardPolicyReject implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if(!executor.isShutdown()){
            if(r instanceof FutureTask){
                FutureTask task = (FutureTask)r;
                // 会抛出CancellationException
                task.cancel(true);
            }
        }
    }
}
线程工厂接口
package com.panda.service.pool.service;

import java.util.concurrent.ExecutorService;

/**
 * 线程工厂接口
 * @author w
 * @date 2020-12-08
 */
public interface ThreadFactoryService<P> {

    /**
     * 执行任务(自动线程池)
     * @param publicInfo 公共信息
     */
    void execute(P publicInfo) throws Exception;

    /**
     * 执行任务(指定线程池)
     * @param publicInfo 公共信息
     * @param pool 指定线程池
     */
    void execute(P publicInfo, ExecutorService pool) throws Exception;
}
抽象线程工厂
package com.panda.service.pool.service;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

/**
 * 线程工厂
 * @param <P> 公共信息
 * @param <R> 执行任务返回结果
 * @author w
 * @date 2020-12-09
 */
@Slf4j
public abstract class AbstractThreadFactoryService<P,R> implements ThreadFactoryService<P> {

    /**
     * 执行线程任务(自动线程池)
     * @param publicInfo 公共信息
     */
    @Override
    public void execute(P publicInfo) throws Exception{
        execute(publicInfo, null);
    }

    /**
     * 执行线程任务
     * @param publicInfo 公共信息
     * @param pool 指定线程池，若设置null则自动调用buildPool构建线程池并且自动销毁
     */
    @Override
    public void execute(P publicInfo, ExecutorService pool) throws Exception{
        // 线程任务
        List<Callable<R>> threads = null;
        // 任务结果集
        List<Future<R>> futures = null;

        // 是否自动销毁线程池
        boolean poolDestroyFlag = null == pool;

        try{
            // 执行任务之前做点什么
            if(!before(publicInfo)){
                log.info("before method returns false.");
                return;
            }

            // 创建任务
            threads = createTask(publicInfo);
            if(null == threads || threads.size() == 0){
                log.info("No task.");
                return;
            }

            // 构建线程池
            if(poolDestroyFlag){
                pool = buildPool(publicInfo);
                Optional.ofNullable(pool).orElseThrow(() -> new Exception("ExecutorService is empty!"));
            }

            // 执行任务
            futures = new ArrayList<>();
            for(Callable<R> thread : threads){
                // 提交任务
                Future<R> future = pool.submit(thread);
                // 保存任务结果
                futures.add(future);
            }

            // 轮询结果，此处会阻塞主线程，等待所有任务处理完成
            for(Future<R> future : futures){
                R response = null;
                try{
                    // 获取执行结果
                    response = future.get();
                }catch (Exception e){
                    // 执行任务结果处理（异常处理）
                    doResult(publicInfo, e);
                }

                // 执行任务结果处理
                if(null != response){
                    doResult(publicInfo, response);
                }
            }

            // 执行任务之后做点什么
            if(!after(publicInfo)){
                log.info("after method returns false.");
            }

        }finally {
            if(null != pool){
                log.info("pool shutdown.");
                pool.shutdown();
            }

            if(null != threads){
                log.info("threads clear.");
                threads.clear();
            }

            if(null != futures){
                log.info("futures clear.");
                futures.clear();
            }
        }
    }

    /**
     * 构建线程池
     * @param publicInfo 公共信息
     * @return 线程池
     */
    protected abstract ExecutorService buildPool(P publicInfo);

    /**
     * 执行任务之前做点什么
     * @param publicInfo 公共信息
     * @return boolean 是否继续执行
     */
    protected abstract boolean before(P publicInfo);

    /**
     * 创建任务
     * @param publicInfo 公共信息
     * @return 任务集
     */
    protected abstract List<Callable<R>> createTask(P publicInfo);

    /**
     * 任务结果处理
     * @param publicInfo 公共信息
     * @param response 处理结果
     */
    protected abstract void doResult(P publicInfo, R response);

    /**
     * 任务结果处理(异常时)
     * @param publicInfo 公共信息
     * @param exception 异常信息
     */
    protected abstract void doResult(P publicInfo, Exception exception);

    /**
     * 执行任务之后做点什么
     * @param publicInfo 公共信息
     * @return boolean 是否继续执行
     */
    protected abstract boolean after(P publicInfo);
}

<调用例子>

新增多线程业务
package com.panda.service.test.task.thread;

import com.alibaba.fastjson.JSONObject;
import com.panda.service.test.task.vo.OrderCheckInfo;
import com.panda.service.test.task.vo.OrderCheckResponse;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;

/**
 * 订单检查异步线程处理
 * @author w
 * @date 2020-12-09
 */
@Slf4j
public class OrderCheckThread implements Callable<OrderCheckResponse> {

    /** 订单信息 **/
    private OrderCheckInfo orderCheckInfo;

    public OrderCheckThread(OrderCheckInfo orderCheckInfo){
        this.orderCheckInfo = orderCheckInfo;
    }

    @Override
    public OrderCheckResponse call() {
        try{
            log.info("开始执行订单检查:{}", JSONObject.toJSONString(orderCheckInfo));
            return new OrderCheckResponse(true, "交易成功", orderCheckInfo.getOrderId());
        }catch (Exception e){
            log.error(e.getMessage(),e);
            return new OrderCheckResponse(false, "交易异常" + e.getMessage(), orderCheckInfo.getOrderId());
        }
    }
}
相关vo类
package com.panda.service.test.task.vo;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 订单检查信息
 */
@AllArgsConstructor
@Data
public class OrderCheckInfo {
    private String orderId;
}


package com.panda.service.test.task.vo;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 订单检查响应结果
 */
@AllArgsConstructor
@Data
public class OrderCheckResponse {
    private boolean status;
    private String result;
    private String orderId;
}

package com.panda.service.test.task.vo;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * 会话信息
 */
@AllArgsConstructor
@Data
public class SessionInfo {
    private String oprId;
    private String oprName;
}
实现抽象工厂接口，个性化业务处理
package com.panda.service.test.task.service;

import com.alibaba.fastjson.JSONObject;
import com.panda.service.pool.config.ThreadFactoryConfig;
import com.panda.service.pool.factory.NameThreadFactoryBuilder;
import com.panda.service.pool.factory.ThreadFactoryBuilder;
import com.panda.service.pool.reject.DiscardPolicyReject;
import com.panda.service.pool.service.AbstractThreadFactoryService;
import com.panda.service.test.task.thread.OrderCheckThread;
import com.panda.service.test.task.vo.OrderCheckInfo;
import com.panda.service.test.task.vo.OrderCheckResponse;
import com.panda.service.test.task.vo.SessionInfo;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 订单检查
 * @author w
 * @date 2020-12-09
 */
@Slf4j
public class OrderCheckService extends AbstractThreadFactoryService<SessionInfo, OrderCheckResponse> {
    @Override
    protected ExecutorService buildPool(SessionInfo sessionInfo) {
        ThreadFactoryConfig config = new ThreadFactoryConfig();
        config.setCorePoolSize(10);
        config.setMaximumPoolSize(20);
        config.setKeepAliveTime(0L);
        config.setTimeUnit(TimeUnit.MILLISECONDS);
        // 采用有界队列
        config.setBlockingQueue(new LinkedBlockingQueue<>(10));
        // 饱和策略采用DiscardPolicy，剩下的任务丢掉不执行
        config.setRejectedExecutionHandler(new DiscardPolicyReject());
        config.setThreadFactory(NameThreadFactoryBuilder.buildThreadFactory("order-check"));
        return ThreadFactoryBuilder.buildThreadPool(config);
    }

    @Override
    protected boolean before(SessionInfo sessionInfo) {
        log.info("在执行任务之前做点什么吧");
        return true;
    }

    @Override
    protected List<Callable<OrderCheckResponse>> createTask(SessionInfo sessionInfo) {
        List<Callable<OrderCheckResponse>> tasks = new ArrayList<>();
        // TODO 测试
        for(int i=0;i<50;i++){
            tasks.add(new OrderCheckThread(new OrderCheckInfo(System.currentTimeMillis() + "_" + i)));
        }
        return tasks;
    }

    @Override
    protected void doResult(SessionInfo sessionInfo, OrderCheckResponse response) {
        log.info("执行结果: {}", JSONObject.toJSONString(response));
    }

    @Override
    protected void doResult(SessionInfo sessionInfo, Exception exception) {
        if(exception instanceof CancellationException){
            log.info("执行异常结果: 线程池和队列都满了，触发饱和策略！");
        }else{
            log.info("执行异常结果: {}",exception.getMessage());
        }
    }

    @Override
    protected boolean after(SessionInfo sessionInfo) {
        log.info("在执行任务之后做点什么吧");
        return true;
    }
}
执行结果
22:46:02.580 [main] INFO com.panda.service.test.task.service.OrderCheckService - 在执行任务之前做点什么吧
22:46:02.722 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_27"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_0"}
22:46:02.724 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_7"}
22:46:02.724 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_24"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_20"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_25"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_22"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_26"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_9"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_4"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_3"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_28"}
22:46:02.722 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_1"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_8"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_12"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_13"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_15"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_17"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_19"}
22:46:02.724 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_21"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_18"}
22:46:02.724 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_23"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_2"}
22:46:02.722 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_29"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_11"}
22:46:02.724 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_10"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_14"}
22:46:02.724 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_5"}
22:46:02.725 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_16"}
22:46:02.723 [order-check] INFO com.panda.service.test.task.thread.OrderCheckThread - 开始执行订单检查:{"orderId":"1607784362586_6"}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_0","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_1","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_2","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_3","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_4","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_5","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_6","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_7","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_8","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_9","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_10","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_11","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_12","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_13","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_14","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_15","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_16","result":"交易成功","status":true}
22:46:02.730 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_17","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_18","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_19","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_20","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_21","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_22","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_23","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_24","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_25","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_26","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_27","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_28","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行结果: {"orderId":"1607784362586_29","result":"交易成功","status":true}
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.731 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.732 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.732 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.734 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.734 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.734 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.734 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 执行异常结果: 线程池和队列都满了，触发饱和策略！
22:46:02.735 [main] INFO com.panda.service.test.task.service.OrderCheckService - 在执行任务之后做点什么吧
22:46:02.735 [main] INFO com.panda.service.pool.service.AbstractThreadFactoryService - after method returns false.
22:46:02.735 [main] INFO com.panda.service.pool.service.AbstractThreadFactoryService - pool shutdown.
22:46:02.735 [main] INFO com.panda.service.pool.service.AbstractThreadFactoryService - threads clear.
22:46:02.735 [main] INFO com.panda.service.pool.service.AbstractThreadFactoryService - futures clear.

Process finished with exit code 0
一只懒惰的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池之ThreadPoolExecutor使用
weixin_42656411的博客
03-23 2183
ThreadPoolExecutor使用
线程池的使用ThreadPoolExecutor
qq_38667268的博客
12-12 1229
线程池意味着可以储存线程，并让池内的线程得以复用，如果池内的某一个线程执行完了，并不会直接销毁它有生命周期，可以存活一些时间，待到下一个任务来时，它会复用这个在等待中的线程，避免了再去创建线程增加的额外系统开销。CachedThreadPool∶:允许的创建线程数量为Integer .NAX_VALE，可能会创建大量的线程，我们知道每个线程默认情况下占1M的内存空间，如果线程非常多，内存资源将会被耗尽，从而导致OOM。创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。
ThreadPoolExecutor线程池的使用方法
08-25
主要为大家详细介绍了ThreadPoolExecutor线程池的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
ThreadPoolExecutor线程池的使用与理解
Thinking_IN_Java
05-26 3158
ThreadPoolExecutor线程池的使用与理解 线程池的作用就是用尽可能少的线程来执行尽可能多的Runnable，以实现对线程的充分利用。 从ThreadPoolExecutor类的构造方法说起：ThreadPoolExecutor public ThreadPoolExecutor(int corePoolSize, // 核心线程数
多线程--线程池（ThreadPoolExecutor）
最新发布
m0_73957629的博客
07-29 937
多线程 线程池
ThreadPoolExecutor
qq_39416605的博客
06-09 232
文章目录为什么要使用线程池线程池详解线程池的创建线...
深入理解Java线程池：ThreadPoolExecutor
weixin_30871701的博客
01-02 488
线程池介绍 在web开发中，服务器需要接受并处理请求，所以会为一个请求来分配一个线程来进行处理。如果每次请求都新创建一个线程的话实现起来非常简便，但是存在一个问题： 如果并发的请求数量非常多，但每个线程执行的时间很短，这样就会频繁的创建和销毁线程，如此一来会大大降低系统的效率。可能出现服务器在为每个请求创建新线程和销毁线程上花费的时间和消耗的系统资源要比处理实际的用户请求的时间和资源更多。 ...
线程池详解 ThreadPoolExecutor
扶摇而上九万里
04-24 1776
一、ThreadPoolExecutor类讲解 1、线程池状态： 五种状态： 线程池的shutdown()方法，将线程池由 RUNNING（运行状态）转换为 SHUTDOWN状态 线程池的shutdownNow()方法，将线程池由RUNNING 或 SHUTDOWN 状态转换为 STOP 状态。 注：SHUTDOWN状态 和 STOP 状态 先会转变为TIDYING状态，最终都会变为TERMINATED 2、ThreadPoolExecutor构造函数： Thr...
线程池ThreadPoolExecutor使用简介与方法实例
08-26
线程池ThreadPoolExecutor使用简介与方法实例 线程池ThreadPoolExecutor是Java并发编程中一个非常重要的概念，它允许开发者将任务提交给线程池，并由线程池来管理这些任务的执行。今天，我们将对线程池...
java线程池ThreadPoolExecutor类使用详解.docx
06-21
在《阿里巴巴java开发手册》中...另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。
PyQt5中多线程模块QThread和线程池ThreadPoolExecutor解决PyQt5界面程序执行比较耗时操作无响应问题
07-09
1.资源简介：PyQt5中使用多线程模块QThread解决了PyQt5界面程序执行比较耗时操作时，程序卡顿出现的无响应以及界面输出无法实时显示的问题，采用线程池ThreadPoolExecutor解决了ping多个IP多任务耗时问题。...
【第十一篇】Java线程池ThreadPoolExecutor使用详解【重点】_java threadpoolexecutor
2401_84520401的博客
04-21 796
引入线程池的原因1、减少开销提升效率减少线程的创建和销毁所花的时间以及系统资源的开销；同时，提高系统响应速度，当有新任务到达时，通过复用已存在的线程，无需等待新线程的创建便可立即执行。2、提高线程的可管理性方便管控线程并发数量。线程无限制的创建，可能会导致内存占用过多，从而产生OOM，并且会造成CPU过度切换，CPU切换线程是有时间成本的：需要保持当前执行线程的现场，并恢复要执行线程的现场。对线程进行统一的分配、调优和监控，从而也提高响应速度；提供更强大的功能，延时定时线程池。
ThreadPoolExecutor线程池使用
World哥
07-07 254
ThreadPoolExecutor线程池使用简介ThreadPoolExecutor线程添加策略提交任务executesubmitinvokeAnyinvokeAllshutdownshutdownNowisShutdownisTerminatedawaitTermination 简介 线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。
ThreadPoolExecutor线程池的使用
我只是一个简单的Coder，为了兴趣和理想奋斗在生活的道路上
04-18 1660
大家先从ThreadPoolExecutor的总体流程入手：  针对ThreadPoolExecutor代码，我们来看下execute方法： [java] view plaincopy public void execute(Runnable command) {           if (command == null)
ThreadPoolExecutor 线程池的使用
@chenk的博客
06-21 2238
1.状态不允许提交新的任务，也不会处理阻塞队列中未执行的任务，并设置正在执行的线程的中断标志位2.构造参数含义：corePoolSize： 线程池维护线程的最少数量 maximumPoolSize：线程池维护线程的最大数量 keepAliveTime： 线程池维护线程所允许的空闲时间 unit： 线程池维护线程所允许的空闲时间的单位 workQueue： 线程池所使用的缓冲队列 handler： 线程池对拒绝任务的处理策略 拒绝策略： 原理：实际上，线程池ThreadPoolExecutor的
java ThreadPoolExecutor 线程池使用
小道士写程序
10-25 328
package com.javaitem.college.thread.action; /** * 多线程测试， * 线程池测试 1 自动创建线程池（ aliy代码检测不建议 ），2手动创建线程池（ aliy代码检测建议 ） * ThreadPoolExecutor类提供了4种构造方法，可根据需要来自定义一个线程池。 */ import cn.hutool.core.date.DateUtil; import cn.hutool.http.HttpUtil; import java.u.
Java线程池ThreadPoolExecutor使用，附上代码
03-07
Java线程池ThreadPoolExecutor是Java提供的一个用于管理和复用线程的工具类。它可以帮助我们更有效地管理线程资源，提高程序的性能和可维护性。 下面是一个简单的使用ThreadPoolExecutor的示例代码： ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExample { public static void main(String[] args) { // 创建一个线程池，其中包含5个线程 ExecutorService executor = Executors.newFixedThreadPool(5); // 提交任务给线程池执行 for (int i = 0; i < 10; i++) { Runnable worker = new WorkerThread("Task " + i); executor.execute(worker); } // 关闭线程池 executor.shutdown(); while (!executor.isTerminated()) { // 等待所有任务完成 } System.out.println("所有任务已完成"); } } class WorkerThread implements Runnable { private String taskName; public WorkerThread(String taskName) { this.taskName = taskName; } @Override public void run() { System.out.println(Thread.currentThread().getName() + " 开始执行任务：" + taskName); try { // 模拟任务执行时间 Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " 完成任务：" + taskName); } } ``` 上述代码中，首先通过`Executors.newFixedThreadPool(5)`创建了一个包含5个线程的线程池。然后使用`executor.execute(worker)`提交任务给线程池执行，其中`worker`是实现了`Runnable`接口的任务对象。任务会被线程池中的线程异步执行。 最后，通过`executor.shutdown()`关闭线程池，并使用`executor.isTerminated()`等待所有任务完成。完成后输出"所有任务已完成"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值