采用多線程在Redis更新完以後批量更新狀态

今天遇到一個為題在更新較多狀态時，springboot定時任務可能會導緻應用連接配接池出問題

采用批量更新

采用多線程在Redis更新完以後批量更新狀态

package com.reformer.demo2.job;

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONArray;

import com.alibaba.fastjson.JSONObject;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.reformer.common.redis.JedisClient;

import com.reformer.demo2.entity.dao.TArrearsOrderMapper;

import com.reformer.demo2.entity.dao.TSysParamMapper;

import com.reformer.demo2.entity.po.TArrearsOrder;

import com.reformer.demo2.entity.po.TSysParam;

import com.reformer.demo2.util.SysConfig;

import lombok.extern.slf4j.Slf4j;

import org.apache.poi.ss.formula.functions.T;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

import redis.clients.jedis.Jedis;

import java.net.URLEncoder;

import java.util.*;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.stream.Collectors;

@Slf4j

@Component

public class RedisOrderJob {

private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);

@Value("${TArrearsOrderRedis}")

private String TArrearsOrderRedis;

@Autowired

private TArrearsOrderMapper tarrearsOrderMapper;

@Autowired

protected JedisClient jedisClient;

@Autowired

protected TSysParamMapper tSysParamMapper;

@Scheduled(cron = "0 0/3 * * * ? ")
public void redisOrderUpdate() throws Exception {

    log.info("開始更新redis待追繳訂單");
    Jedis jedis = jedisClient.getJedis();
    TSysParam tSysParam = tSysParamMapper.selectById(1);
    SysConfig.redislistMax=tSysParam.getIntparam();
    QueryWrapper<TArrearsOrder> queryWrapper = new QueryWrapper();
    queryWrapper.eq("status", 0);
    List<TArrearsOrder> tArrearsOrders = tarrearsOrderMapper.selectList(queryWrapper);
    if (tArrearsOrders.size()>0) {
        for (TArrearsOrder tArrearsOrder : tArrearsOrders) {
            String carnoEncode = URLEncoder.encode(tArrearsOrder.getCarno(),"utf-8");
            String Key =  carnoEncode + tArrearsOrder.getColor();
            Long scard = jedis.scard(Key);
                if (scard >= SysConfig.redislistMax) {
                    continue;
                } else {
                    Set<String> smembers = jedis.smembers(Key);
                    ArrayList<String> strings = new ArrayList<>();
                    Iterator<String> it = smembers.iterator();
                    while (it.hasNext()) {
                        String str = it.next();
                        strings.add(JSON.parseObject(str).getString("orderNo"));
                    }
                    if (!strings.contains(tArrearsOrder.getOrderNo())) {
                        jedisClient.sadd(Key,JSON.toJSONString(tArrearsOrder));
                        tArrearsOrder.setIsredis(0);

                    }
                }

        }
        List<List<TArrearsOrder>> lists = splitList(tArrearsOrders, 500);
        try {
        for (List<TArrearsOrder> list : lists) {
            executor.execute(() -> tarrearsOrderMapper.batchUpdate(list));
        }
        } catch (Exception e) {
            log.warn("批量更新list 失敗");
        }
        executor.shutdown();
        log.info("批量更新狀态成功");
    }
    jedis.close();

}
public static List<List<TArrearsOrder>> splitList(List<TArrearsOrder> list, int len) {
    if (list == null || list.size() == 0 || len < 1) {
        return null;
    }

    List<List<TArrearsOrder>> result = new ArrayList<List<TArrearsOrder>>();


    int size = list.size();
    int count = (size + len - 1) / len;


    for (int i = 0; i < count; i++) {
        List<TArrearsOrder> subList = list.subList(i * len, ((i + 1) * len > size ? size : len * (i + 1)));
        result.add(subList);
    }
    return result;
}
           

}