<!-- Redis 配置 排除默認(rèn)啟動(dòng)-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
     <exclusions>
         <exclusion>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
         </exclusion>
     </exclusions>
 </dependency>
 <!--redis連接池-->
 <dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>commons-pool2</artifactId>
     <version>2.9.0</version>
 </dependency>
 <!--jedis-->
 <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>2.9.0</version>
 </dependency>
 <!--aspectj-->
 <dependency>
     <groupId>org.aspectj</groupId>
     <artifactId>aspectjweaver</artifactId>
     <version>1.9.7</version>
 </dependency>

upload:
	#每天幾點(diǎn)幾分執(zhí)行
	taskOnecron: 0 25 22 ? * *
	#每2分鐘執(zhí)行一次
	taskTwocron: 0 0/2 * * * ?
spring:
    redis:
        #數(shù)據(jù)庫索引
        database: 0
        host: 127.0.0.1
        port: 6379
        password:
        jedis:
            pool:
                #最大連接數(shù)
                max-active: 8
                #最大阻塞等待時(shí)間(負(fù)數(shù)表示沒限制)
                max-wait: -1
                #最大空閑
                max-idle: 8
                #最小空閑
                min-idle: 0
                #連接超時(shí)時(shí)間
        timeout: 10000

package com.xz.jdk11.schedule.aop;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * @author xz
 * @description 自定義redis鎖注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface RedisLock {
    //鎖前綴
    String lockPrefix() default "SCHEDULE_REDISLOCK:";
    //鍵
    String lockKey() default "";
    //默認(rèn)超時(shí)時(shí)間（秒）
    long TimeOut() default 60;
    //默認(rèn)超時(shí)時(shí)間單位 （秒）
    TimeUnit timeUtil() default TimeUnit.SECONDS;
}

package com.xz.jdk11.schedule.aop;

import cn.hutool.core.util.StrUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * @author xz
 * @description redis鎖切面
 */
@Aspect
@Component
public class RedisLockAspect {
    private static final Logger log = LoggerFactory.getLogger(RedisLock.class);

    //最大重試次數(shù)
    private static final Integer MAX_RETRY_COUNT=3;
    //鎖前綴
    private static final String LOCK_PRE_FIX="lockPreFix";
    //鍵
    private static final String LOCK_KEY="lockKey";
    //超時(shí)時(shí)間
    private static final String TIME_OUT="timeOut";
    //保護(hù)時(shí)間 2*2^11 =4096
    private static final int PROTECT_TIME= 2 << 11;

    @Autowired
    private CommonRedisHelper commonRedisHelper;

    //切點(diǎn)
    @Pointcut("@annotation(com.xz.jdk11.schedule.aop.RedisLock)")
    public void RedisLockAspect(){

    }

    //通知
    @Around(value="RedisLockAspect()")
    public void lockRoundAction(ProceedingJoinPoint proceeding){
        //獲取redis鎖
        boolean flag = this.getLock(proceeding, 0, System.currentTimeMillis());
        if(flag){
            try {
                proceeding.proceed();
                Thread.sleep(PROTECT_TIME);
            } catch (Throwable e) {
                throw new RuntimeException("定時(shí)任務(wù)======>>>redis分布式鎖執(zhí)行發(fā)生異常："+e.getMessage(),e);
            }finally {
                //刪除鎖
                this.delLock(proceeding);
            }
        }else{
            log.info("定時(shí)任務(wù)======>>>其他服務(wù)器正在執(zhí)行此定時(shí)任務(wù)");
        }
    }

    /**
     * 獲取鎖
     */
    private boolean getLock(ProceedingJoinPoint proceeding,int count,long currentTime){
        //獲取鎖參數(shù)
        Map<String, Object> annotationArgs = this.getAnnotationArgs(proceeding);
        String  lockPreFix = (String) annotationArgs.get(LOCK_PRE_FIX);
        String  lockKey = (String) annotationArgs.get(LOCK_KEY);
        long  timeOut = (Long) annotationArgs.get(TIME_OUT);
        if(StrUtil.isEmpty(lockPreFix) || StrUtil.isEmpty(lockKey)){
            throw  new RuntimeException("定時(shí)任務(wù)======>>>RedisLock 鎖前綴（LOCK_PRE_FIX）或者鎖名（LOCK_KEY）未設(shè)置");
        }
        if(commonRedisHelper.setNx(lockPreFix,lockKey,timeOut)){
            log.info("定時(shí)任務(wù)======>>>RedisLock:{}線程，已獲取到鎖",Thread.currentThread().getName());
            return true;
        }else{
            //如果當(dāng)前時(shí)間與鎖的時(shí)間差，大于保護(hù)時(shí)間，則強(qiáng)制刪除鎖（防止死鎖）
            long creatTime = commonRedisHelper.getLockValue(lockPreFix, lockKey);
            if((currentTime - creatTime) >timeOut * 1000 + PROTECT_TIME){
                count ++;
                if(count > MAX_RETRY_COUNT){
                    return  false;
                }
                commonRedisHelper.delete(lockPreFix,lockKey);
                getLock(proceeding,count,currentTime);
            }
            log.info("定時(shí)任務(wù)======>>>正在執(zhí)行定時(shí)任務(wù)key：{}",lockKey);
            log.info("定時(shí)任務(wù)======>>>RedisLock===={}線程，獲取鎖失敗",Thread.currentThread().getName());
            return false;
        }
    }

    /**
     * 刪除鎖
     */
    private void delLock(ProceedingJoinPoint proceedingJoinPoint){
        //獲取鎖參數(shù)
        Map<String, Object> annotationArgs = this.getAnnotationArgs(proceedingJoinPoint);
        String  lockPreFix = (String) annotationArgs.get(LOCK_PRE_FIX);
        String  lockKey = (String) annotationArgs.get(LOCK_KEY);
        //刪除鎖
        commonRedisHelper.delete(lockPreFix,lockKey);
    }

    /**
     * 獲取鎖參數(shù)
     * @param proceeding
     * */
    public Map<String,Object> getAnnotationArgs(ProceedingJoinPoint proceeding){
        Class<?> target = proceeding.getTarget().getClass();
        //獲取所有方法
        Method[] methods = target.getMethods();
        //獲取方法名稱
        String methodName = proceeding.getSignature().getName();
        for(Method method:methods){
            if(method.getName().equals(methodName)){
                HashMap<String, Object> hashMap = new HashMap<>();
                RedisLock redisLock = method.getAnnotation(RedisLock.class);
                hashMap.put(LOCK_PRE_FIX,redisLock.lockPrefix());
                hashMap.put(LOCK_KEY,redisLock.lockKey());
                hashMap.put(TIME_OUT,redisLock.timeUtil().toSeconds(redisLock.TimeOut()));
                return hashMap;
            }
        }
        return new HashMap<>();
    }
}

package com.xz.jdk11.schedule.aop;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * @author xz
 * @description redis命令操作類
 */
@Component
public class CommonRedisHelper {
    @Autowired
    RedisTemplate<Object,Object> redisTemplate;
    /**
     * 添加分布式鎖
     * */
    public boolean setNx(String track,String sector,long timeout){
        boolean flag =false;
        ValueOperations<Object, Object> valueOperations = redisTemplate.opsForValue();
        flag=valueOperations.setIfAbsent(track+sector,System.currentTimeMillis());
        if(flag){
            valueOperations.set(track+sector,getLockValue(track,sector),timeout, TimeUnit.SECONDS);
        }
        return flag;
    }

    /**
     * 刪除鎖
     * @param lockPreFix 前綴
     * @param key 鍵
     * */
    public void delete(String lockPreFix,String key){
        redisTemplate.delete(lockPreFix+key);
    }

    /**
     * 查詢鎖
     * @return 寫鎖時(shí)間
     * */
    public long getLockValue(String track,String sector){
        return (long) redisTemplate.opsForValue().get(track+sector);
    }
}

package com.xz.jdk11.schedule;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Calendar;

/**
 * @author xz
 * @description 定時(shí)任務(wù)一（每天幾點(diǎn)幾分執(zhí)行）
 */
@Slf4j
@Component
public class TaskOne implements BaskTask{
    @Value("${upload.taskOnecron}")
    private String taskOnecron;

    @Override
    public String getCron() {
        return taskOnecron;
    }

    @Override
    public void execute() {
        log.info("定時(shí)任務(wù)一（每天幾點(diǎn)幾分執(zhí)行一次）,執(zhí)行開始時(shí)間：{}",Calendar.getInstance().getTime());
    }
    @Override
    @RedisLock(lockKey = "run",TimeOut = 60)
    public void run() {
        execute();
    }
}

package com.xz.jdk11.schedule;
import com.xz.jdk11.schedule.aop.RedisLock;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Calendar;

/**
 * @author xz
 * @description 定時(shí)任務(wù)一（每幾分鐘執(zhí)行一次，共執(zhí)行幾次）
 */
@Slf4j
@Component
public class TaskTwo implements BaskTask{
    @Value("${upload.taskTwocron}")
    private String taskTwocron;

    @Override
    public String getCron() {
        return taskTwocron;
    }

    @Override
    public void execute() {
        log.info("定時(shí)任務(wù)二：每幾分鐘執(zhí)行一次,執(zhí)行開始時(shí)間：{}", Calendar.getInstance().getTime());
    }

    @Override
    @RedisLock(lockKey = "run",TimeOut = 60)
    public void run() {
        execute();
    }
}