前言

最近項(xiàng)目中需要做一個(gè)定時(shí)任務(wù)在某個(gè)固定的時(shí)間去執(zhí)行一個(gè)任務(wù)，由于該定時(shí)任務(wù)的代碼量已經(jīng)超出可讀性規(guī)范，并且處于性能的考慮，故使用線程池來(lái)做一個(gè)異步執(zhí)行的方法

一、需求分析

產(chǎn)品給到的需求是，讓用戶獲得的能量根據(jù)有效期的規(guī)則配置，去實(shí)現(xiàn)一個(gè)能量過(guò)期的效果，因?yàn)槭莝pringboot單體項(xiàng)目，使用XXLJOB就過(guò)于繁瑣，而且項(xiàng)目中沒(méi)有其它的定時(shí)任務(wù)，私以為使用Scheduled執(zhí)行比較簡(jiǎn)單，易用。然后編寫(xiě)過(guò)程中發(fā)現(xiàn)，代碼行數(shù)太多，按照不能超過(guò)80行的規(guī)范，故將一部分業(yè)務(wù)拆分出去，并使用線程池異步執(zhí)行。

二、使用步驟

1.配置線程池

代碼如下：

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.ThreadPoolExecutor;


@Configuration
@EnableAsync//開(kāi)啟異步
public class ThreadPoolTaskConfig {
    @Bean("threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(16);
        executor.setQueueCapacity(1024);
        executor.setMaxPoolSize(64);
        executor.setKeepAliveSeconds(30);
        executor.setThreadNamePrefix("thread-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        executor.initialize();
        return executor;
    }
}

猶豫還要考慮性能安全的問(wèn)題，所以使用Redisson，做一個(gè)鎖

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.port}")
    private Integer port;

    @Bean
    public RedissonClient getRedisson() throws Exception {
        RedissonClient redisson = null;

        Config config = new Config();
        //.setPassword(password)
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        redisson = Redisson.create(config);
        System.out.println(redisson.getConfig());

        return redisson;
    }
}

需要注意的是，其中的@Value已經(jīng)在yml配置文件中配置好了，這里不再記錄

2.編寫(xiě)能量過(guò)期方法

代碼如下：

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hsbc.component.AddOutEnergyComponent;
import com.hsbc.enums.EnergyType;
import com.hsbc.mapper.EnergyRecordMapper;
import com.hsbc.model.EnergyRecord;
import com.hsbc.model.EnergyRule;
import com.hsbc.service.IEnergyRecordsService;
import com.hsbc.service.IEnergyRuleService;
import com.hsbc.enums.DelFlagEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;


@Configuration
@EnableScheduling//開(kāi)啟定時(shí)任務(wù)
@Slf4j
public class EneryOutTask {

    @Autowired
    private EnergyRecordMapper energyRecordMapper;

    @Resource
    private RedissonClient redissonClient;
    @Autowired
    private AddOutEnergyComponent addOutEnergyComponent;

    public static final String ENERGY_OUT_LOCK_KEY = "energy:out:lock:%s";

    /**
     * 定時(shí)任務(wù)
     * 每月月初00：00：00執(zhí)行
     * 已過(guò)期的能量處理
     */
    @Scheduled(cron = "0 0 0 1 * ?")
    public void outEnergy() {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String format = sdf.format(date);
        String accessLock = String.format(ENERGY_OUT_LOCK_KEY,format);
        try {
            RLock lock = redissonClient.getLock(accessLock);
            boolean isLock = lock.tryLock(-1, 100, TimeUnit.SECONDS);
            if (isLock) {
                try {
                    /*獲取到本月的最后時(shí)間*/
                    Calendar calendar = Calendar.getInstance();
                    calendar.add(Calendar.MONTH, -1);
                    calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
                    calendar.set(Calendar.HOUR_OF_DAY, calendar.getActualMaximum(Calendar.HOUR_OF_DAY));
                    calendar.set(Calendar.MINUTE, calendar.getActualMaximum(Calendar.MINUTE));
                    calendar.set(Calendar.SECOND, calendar.getActualMaximum(Calendar.SECOND));
                    calendar.set(Calendar.MILLISECOND, calendar.getActualMaximum(Calendar.MILLISECOND));
                    QueryWrapper<EnergyRecord> queryWrapper = new QueryWrapper<>();
                    queryWrapper.le("validity_time", calendar.getTime());
                    queryWrapper.eq("del_flag", DelFlagEnum.NO_DEL.getCode());
                    /*過(guò)期和代扣的能量不統(tǒng)計(jì)*/
                    queryWrapper.ne("type", EnergyType.REDUCE_ENERY.getCode());
                    queryWrapper.ne("type", EnergyType.EXPIRE.getCode());
                    /*所有到期的能量*/
                    List<EnergyRecord> energyRecords = energyRecordMapper.selectList(queryWrapper);
                    Map<String, Integer> outEnergyMap = new HashMap<>(energyRecords.size()); //會(huì)員即將到期的能量map
                    Map<String, List<String>> outEnergyIdsMap = new HashMap<>(); //全部到期準(zhǔn)備刪除的能量id
                    for (EnergyRecord energyRecord : energyRecords) {

                        Integer outEnergy = outEnergyMap.get(energyRecord.getMemberId());
                        if (outEnergy == null) {
                            outEnergy = 0;
                        }
                        outEnergy += energyRecord.getResidualEnergy();
                        outEnergyMap.put(energyRecord.getMemberId(), outEnergy);
                        List<String> list = outEnergyIdsMap.get(energyRecord.getMemberId());
                        if (list == null) {
                            list = new ArrayList<>();
                        }
                        list.add(energyRecord.getId());
                        outEnergyIdsMap.put(energyRecord.getMemberId(), list);
                    }
                    for (Map.Entry<String, Integer> entry : outEnergyMap.entrySet()) {
                        /*異步添加*/
                        addOutEnergyComponent.add(entry.getKey(), entry.getValue(), outEnergyIdsMap.get(entry.getKey()));
                    }
                } finally {
                    log.info("操作業(yè)務(wù)完畢，開(kāi)始釋放鎖");
                    lock.unlock();
                }
            } else {
                log.info("當(dāng)前過(guò)期能量定時(shí)任務(wù)已被執(zhí)行!!");
            }
        } catch (Exception e) {
            log.error("已過(guò)期能量定時(shí)任務(wù)報(bào)錯(cuò)", e);
        }
    }
}

3.編寫(xiě)異步執(zhí)行方法

代碼如下：

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hsbc.enums.DelFlagEnum;
import com.hsbc.enums.EnergyReadEnum;
import com.hsbc.enums.EnergyType;
import com.hsbc.mapper.EnergyRecordMapper;
import com.hsbc.model.EnergyRecord;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;

@Component
@Slf4j
public class AddOutEnergyComponent {

    @Autowired
    private EnergyRecordMapper energyRecordMapper;
    //配置線程池
    @Async("threadPoolTaskExecutor")
    public void add(String memberId, Integer energy, List<String> outIds) {
        QueryWrapper<EnergyRecord> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("member_id", memberId);
        queryWrapper.orderByDesc("id");
        Page<EnergyRecord> page = new Page<>(1, 1);
        Page<EnergyRecord> energyRecordPage = energyRecordMapper.selectPage(page, queryWrapper);
        int lastEnergy = 0;
        if (CollectionUtils.isNotEmpty(energyRecordPage.getRecords())) {
            EnergyRecord energyRecord = energyRecordPage.getRecords().get(0);
            lastEnergy = energyRecord.getBeforeEnergy() + energyRecord.getEnergyNumber();
        }
        EnergyRecord energyRecord = new EnergyRecord();
        energyRecord.setMemberId(memberId);
        energyRecord.setBeforeEnergy(lastEnergy);
        energyRecord.setType(EnergyType.EXPIRE.getCode());
        energyRecord.setEnergyNumber(-energy);
        energyRecord.setCreateTime(new Date());
        energyRecord.setAdditional("能量到期");
        energyRecord.setStatus(EnergyReadEnum.READ.getCode());
        energyRecord.setDelFlag(DelFlagEnum.DEL.getCode());
        energyRecordMapper.insert(energyRecord);
        //修改過(guò)期能量為已刪除
        energyRecordMapper.update(null,new UpdateWrapper<EnergyRecord>().in("id",outIds).set("del_flag",DelFlagEnum.DEL));
    }
}

其中該需求是在能量過(guò)期以后，在能量記錄表中添加數(shù)據(jù)，所以涉及另外一張表的數(shù)據(jù)插入操作，至此已經(jīng)完全實(shí)現(xiàn)需求的功能