关于配置执行定时任务和异步任务的线程池配置类

关于配置执行定时任务和异步任务的线程池配置类1
package com.liftsail.rsademo.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.config.Task;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author 张帆
 * @Description 不积跬步无以至千里
 * @Date 2022/11/23 20:50
 */
@Configuration
@Slf4j
public class ThreadPoolConfig implements AsyncConfigurer, SchedulingConfigurer {

    /**
     * 异步任务执行线程池参数
     */
    private static final Integer CORE_POOL_SIZE = 5;
    private static final Integer MAX_POOL_SIZE = 200;
    private static final Integer QUEUE_CAPACITY = 2000;
    private static final String THREAD_NAME_PREFIX = "async-thread-";
    private static final Integer KEEP_ALIVE_SECONDS = 60;

    /**
     * 定时任务线程池线程名前缀
     */
    private static final String SCHEDULER_THEREAD_NAME_PREFIX = "task-";

    /**
     * @param
     * @description: 创建执行spring task定时任务的线程池，调用@scheduled注解的定时任务
     * @author: xiaomifeng1010
     * @date: 2022/3/13
     * @return: TaskScheduler
     **/
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(10);
        threadPoolTaskScheduler.setThreadNamePrefix(SCHEDULER_THEREAD_NAME_PREFIX);
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskScheduler;
    }

    /**
     * @param
     * @description: 创建执行异步任务的线程池，用于调用 @async注解的方法
     * @author: xiaomifeng1010
     * @date: 2022/3/13
     * @return: ThreadPoolTaskExecutor
     **/
    @Bean("asyncThreadPoolTaskExecutor")
    public ThreadPoolTaskExecutor asyncThreadPoolTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        // 核心线程数量
        threadPoolTaskExecutor.setCorePoolSize(CORE_POOL_SIZE);
        // 最大线程数量
        threadPoolTaskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
        // 队列中最大任务数
        threadPoolTaskExecutor.setQueueCapacity(QUEUE_CAPACITY);
        // 线程名称前缀
        threadPoolTaskExecutor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        // 当达到最大线程数时如何处理新任务（拒绝策略）
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 线程空闲后最大存活时间
        threadPoolTaskExecutor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);
        // 初始化线程池
        threadPoolTaskExecutor.initialize();
        // 关闭线程池
        threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskExecutor;
    }

    /**
     * Callback allowing a {@link TaskScheduler
     * TaskScheduler} and specific {@link Task Task}
     * instances to be registered against the given the {@link ScheduledTaskRegistrar}.
     *
     * @param taskRegistrar the registrar to be configured.
     */
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setTaskScheduler(threadPoolTaskScheduler());
    }

    /**
     * The {@link Executor} instance to be used when processing async
     * method invocations.
     */
    @Override
    public Executor getAsyncExecutor() {
        return asyncThreadPoolTaskExecutor();
    }

    /**
     * The {@link AsyncUncaughtExceptionHandler} instance to be used
     * when an exception is thrown during an asynchronous method execution
     * with {@code void} return type.
     */
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (throwable, method, objects) -> {
            log.error("异步任务执行出现异常, message {}, method {}, params {}", throwable, method, objects);
        };
    }
}

@Scheduled和@Async在spring-boot中共享相同的线程池

我已经配置了两个不同的线程池,一个用于@Scheduled和另一个用于@Async.但是,我注意到@Async没有使用线程池.

这是Scheduler配置

@Configuration
@EnableScheduling
public class SchedulerConfig implements SchedulingConfigurer {
    private final int POOL_SIZE = 10;

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(POOL_SIZE);
        threadPoolTaskScheduler.setThreadNamePrefix("my-sched-pool-");
        threadPoolTaskScheduler.initialize();
        scheduledTaskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
    }
}
这是Async的配置

@Configuration
@EnableAsync
public class AppConfig {

 @Bean(name = "asyncTaskExecutor")
    public TaskExecutor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(15);
        executor.setMaxPoolSize(15);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("my-async-pool-");
        executor.initialize();
        return executor;
    }
}
这是我如何调用它们

@Scheduled(fixedRateString = "2000" )
    public void schedule() {
      log.debug("here is the message from schedule");
      asyncMethod();
    }

@Async("asyncTaskExecutor")
public void asyncMethod(){
  log.info("here is the message from async");
}
这是日志

{"thread":"my-sched-pool-1","level":"DEBUG","description":"here is the message from schedule"}
{"thread":"my-sched-pool-1","level":"INFO","description":"here is the message from async"}
您可以注意到,两个日志都具有该调度程序的相同池.但我希望看到第二个来自异步.

如果你声明它们被声明的@Async方法,class你实际上绕过了Spring的代理机制,这就是为什么你的例子不起作用的原因.尝试从单独class注释的方法@Service或任何其他@Component类型调用该方法.

@Service
SomeScheduledClass {

  private final SomeAsyncClass someAsyncClass;

  public SomeScheduledClass(SomeAsyncClass someAsyncClass) {
    this.someAsyncClass = someAsyncClass;
  }

  @Scheduled(fixedRateString = "2000" )
  public void schedule() {
    log.debug("here is the message from schedule");
    someAsyncClass.asyncMethod();
  }
}

@Service
SomeAsyncClass {
  @Async("asyncTaskExecutor")
  public void asyncMethod(){
    log.info("here is the message from async");
  }
}

异步线程池与定时任务线程池
两个线程池都是一样的步骤：

第一步是线程池配置；

第二步写具体定时或异步任务。

先看异步线程池：

package com.xnpool.common.async;
 
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
 
@Configuration
@EnableAsync  // 启用异步任务
public class AsyncConfiguration {
    @Value("${asynctask.corepoolsize}")
    private int corepoolsize;
    @Value("${asynctask.maxpoolsize}")
    private int maxpoolsize;
    @Value("${asynctask.queuecapacity}")
    private int queuecapacity;
    @Value("${asynctask.keepaliveseconds}")
    private int keepaliveseconds;
    @Value("${asynctask.threadnameprefix}")
    private String threadnameprefix;
    @Value("${asynctask.waitfortaskstocompleteonshutdown}")
    private boolean waitfortaskstocompleteonshutdown;
    @Value("${asynctask.awaitterminationseconds}")
    private int awaitterminationseconds;
 
    // 声明一个线程池(并指定线程池的名字)
    @Bean("taskExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程数5：线程池创建时候初始化的线程数
        executor.setCorePoolSize(corepoolsize);
        //最大线程数5：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(maxpoolsize);
        //缓冲队列500：用来缓冲执行任务的队列
        executor.setQueueCapacity(queuecapacity);
        //允许线程的空闲时间60秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(keepaliveseconds);
        //线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix(threadnameprefix);
        /*
         * 线程池对拒绝任务(无线程可用)的处理策略
         * AbortPolicy:丢弃任务,直接抛出java.util.concurrent.RejectedExecutionException异常，默认的策略
         * CallerRunsPolicy:这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功
         * DiscardOldestPolicy: 丢弃队列最前面的任务，然后重新尝试执行任务,会导致被丢弃的任务无法再次被执行
         * DiscardPolicy:抛弃当前任务；会导致被丢弃的任务无法再次被执行,但是不抛出异常
         */
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.setWaitForTasksToCompleteOnShutdown(waitfortaskstocompleteonshutdown);
        executor.setAwaitTerminationSeconds(awaitterminationseconds);
        executor.initialize();
        return executor;
    }
 
}
启用了线程异步任务后，就可以写代码了：

package com.xnpool.common.async;
 
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xnpool.common.constant.AuthConstant;
import com.xnpool.common.mapper.ds1.CCoinMapper;
import com.xnpool.common.mapper.ds1.SubuserMapper;
import com.xnpool.common.mapper.ds2.UserAddressMapper;
import com.xnpool.common.model.CommonCoin;
import com.xnpool.common.model.Subuser;
import com.xnpool.common.model.UserAddress;
import com.xnpool.common.service.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
 
import java.util.*;
import java.util.stream.Collectors;
 
@Slf4j
@Service
public class AsyncTaskService {
    @Autowired
    private UserAddressMapper userAddressMapper;
    @Autowired
    private TableUtil tableUtil;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Autowired
    private CCoinMapper coinMapper;
    @Autowired
    private SubuserMapper subuserMapper;
    @Autowired
    private RedisService redisService;
 
 
 
    /**
     *
     * @param pid 企业id
     * @param aid 应用id
     * @param uid 用户id
     * @param cid 子账号id
     */
    @Async("taskExecutor")//指定了异步线程池名
    public void executeAsyncTask(Long pid,Long aid, String uid, String cid,boolean b) {
        String sql="select coin_id as coinId,coin_name as coinName,price,contract_coin_id as contractCoinId,contract_coin as contractCoin from t_coin";
        /*//查询币种列表  new BeanPropertyRowMapper<CommonCoin>(CommonCoin.class)*/
        //BeanPropertyRowMapper<CommonCoin> rowMapper = new BeanPropertyRowMapper<CommonCoin>(CommonCoin.class);
        List<CommonCoin> coinIds =coinMapper.selectList(new QueryWrapper<CommonCoin>());
        ArrayList<UserAddress> userAddressArrayList = new ArrayList<UserAddress>();
 
        String existsAddress = tableUtil.isExistsAddress(pid);//一个企业一个用户币种关联表。（没有表就先创建）
        log.info("增加用户或子账户的币种地址============");
        if (existsAddress != null && userAddressArrayList.size()>0) {
            userAddressMapper.insertCoinBase(existsAddress, userAddressArrayList);
        }
    }
 
    @Async("taskExecutor")//指定了异步线程池名
    public void executeAsyncCoinTask(Integer coinId, String coinName,Integer isContact, Integer contactCoinId) {
        List<Subuser> ulist=subuserMapper.findAllSubList();
        if(CollectionUtil.isNotEmpty(ulist)){
            Map<Long,List<Subuser>> map=ulist.stream().filter(u->u.getEnterpriseId()!=null).collect(Collectors.groupingBy(Subuser::getEnterpriseId));
            Long platId=getPalateFromId();
 
                String existsAddress = tableUtil.isExistsAddress(pid);//一个企业一个用户币种关联表。（没有表就先创建）
                log.info("增加用户或子账户的币种地址============");
                if (existsAddress != null && userAddressArrayList.size()>0) {
                    userAddressMapper.insertCoinBase(existsAddress, userAddressArrayList);
                }
            }
 
        }
 
    }
 
}
下面贴定时任务线程池：

package com.xnpool.admin.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
 
import java.util.concurrent.Executor;
 
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
 
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskScheduleExecutor());
    }
 
    @Bean(destroyMethod="shutdown")
    public Executor taskScheduleExecutor() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10);
        scheduler.setThreadNamePrefix("schedule_task-");
        scheduler.setAwaitTerminationSeconds(600); 线程池关闭前最大等待时间，确保最后一定关闭
        scheduler.setWaitForTasksToCompleteOnShutdown(true);// 线程池关闭时等待所有任务完成
        return scheduler;
        //return Executors.newScheduledThreadPool(10); //指定线程池大小
    }
}
 
具体使用定时任务的地方：

@Slf4j
@Service
public class SendMessageService {
    @Autowired
    private PushUtil pushUtil;
 
    @Autowired
    private TransactionMapper transactionsMapper;
    @Autowired
    private TUserMapper userMapper;
 
    @Autowired
    private TCoinMapper coinMapper;
 
    @Autowired
    private TNoticeMapper noticeMapper;
    @Autowired
    private TMessageMapper messageMapper;
    @Autowired
    private TableUtil tableUtil;
 
    @Autowired
    private RedisService redisService;
 
 
    /**
     * 推送公告（把公告推送给所有手机用户，推送后，不管用户是否接收，公告状态改为已发送状态）
     */
    @Scheduled(fixedDelay = 1000 * 60 * 5)
    public void sendNotice() {
        List<TNotice> notices = noticeMapper.selectList(new QueryWrapper<TNotice>().lambda().eq(TNotice::getIsSend,0));
        if (notices != null && notices.size() > 0) {
            List<Integer> idList = notices.stream().map(TNotice::getId).collect(Collectors.toList());
            List<TUser> userList = userMapper.selectClientList();
            List<String> clinetList=userList.stream().map(TUser::getClientid).collect(Collectors.toList());
            
 
        }
    }
 
    /**
     * 推送消息(将所有状态是已完成未发送的交易，发送给用户。 发送完就把状态改成已发送。)
     */
    @Scheduled(fixedDelay = 1000 * 10)
    public void sendTx() {
        }

}

这两个定时任务没有指定线程池名字，但已确认它是在线程池ScheduleConfig 中。