传输平台所引发的redis分布式锁

Mars 2019年11月02日 24次浏览

Redis分布式锁

简单锁实现:

/**最好还是设置过期时间,防止死锁
 *<p>redisTemplate.expire(key,timeout,TimeUnit.SECONDS);和setIfAbsent(key,value,timeout,TimeUnit.SECONDS);都可以
 */
boolean lock() {
    return redisTemplate.opsForValue().setIfAbsent(key, value);
}

boolean unlock(){
    redisTemplate.delete(key);
}

gtdq传输平台缓存清理的分布式锁实现:

//这是一个定时任务启动会执行的方法(多个客戶端文件清理需要加锁控制,由于客户端和服务端文件路径不一样,并且服务端只会启动一个,因此服务端清理文件不需要互斥,只是多客户端之间清理文件要互斥,
//所以只需要一个客户端拿到锁即可)。
//redis是客户端和服务端共享的,因此需要互斥,只要一个客户端或者服务端拿到锁即可
public void test() {
    /**
     * LocalDate toString之后格式:2019-08-15 。 LocalDateTime toString之后格式为:"2019-08-15T19:14:01.789461"
     * <p>data-->2019-08-15   time-->19:14:01.789461<p/>
     */
    LocalDateTime currentTime = LocalDateTime.now();


    new Thread(() -> {
        Boolean client = Boolean.valueOf(isClient);
        //清理文件缓存
        if (client) {
            boolean b = holdingLock("executeCleanFileDate", currentTime);
            if (b) {
                System.out.println("客户端拿到锁,开始清理文件");
                cleanFile();
            }

        } else {
            System.out.println("服务端开始清理文件");
            cleanFile();
        }

    }, "清理文件缓存线程").start();

    Thread.currentThread().setName("清理redis缓存线程");
    //清理Redis缓存
    boolean b = holdingLock("executeCleanRedisDate", currentTime);
    if (b) {
        System.out.println("本线程拿到锁,开始清理redis");
        cleanRedis();
    }

}

//当前线程是否持有锁
private boolean holdingLock(String key, LocalDateTime currentTime) {
    //初始化redis锁,当前时间作为锁(redis单线程的,并且setIfAbsent方法在key存在的时候会返回false)
    Boolean isSuccess = redisTemplate.opsForValue().setIfAbsent(key, currentTime.toString());
    if (isSuccess) {
        return true;
    }

    /**
     * 到这儿有两种可能:1.之前有人刚上锁。2.上一次定时任务的锁
     */

    Object current = redisTemplate.opsForValue().get(key);
    //如果锁是当天加的,则证明有其他进程在执行清缓存,直接退出。如果锁不是当天加的,则是之前加的锁,需要更新锁为今天。
    if (currentTime.toLocalDate().toString().equals(((String) redisTemplate.opsForValue().get(key)).substring(0, 10))) {
        System.out.println("没拿到" + key + "锁,直接结束");
        return false;
    } else {
        Object old = redisTemplate.opsForValue().getAndSet(key, currentTime.toString());
        if (current.equals(old)) {//保证了是 第一个 更改redis数据的进程/线程,虽然之后其他线程仍然会更改锁的值,但是已经不影响程序的执行了。
            System.out.println("拿到" + key + "锁");
            return true;
        }
        return false;
    }
}

private void cleanRedis() {
}

private void cleanFile() {
}

其他高并发场景(如秒杀)的分布式锁控制,基本大同小异:

public class RedisLock {

    private StringRedisTemplate redisTemplate;

    /**
     * 加锁
     * @param key 被秒杀商品的id
     * @param value 当前线程操作时的 System.currentTimeMillis() + 2000,2000是超时时间,这个地方不需要去设置redis的expire,
     *              也不需要超时后手动去删除该key,因为会存在并发的线程都会去删除,造成上一个锁失效,结果都获得锁去执行,并发操作失败了就。
     * @return
     */
    public boolean lock(String key, String value) {
        //如果key值不存在,则返回 true,且设置 value
        if (redisTemplate.opsForValue().setIfAbsent(key, value)) {
            return true;
        }

        //获取key的值,判断是是否超时
        String curVal = redisTemplate.opsForValue().get(key);
        if (StringUtils.isNotEmpty(curVal) && Long.parseLong(curVal) < System.currentTimeMillis()) {
            //获得之前的key值,同时设置当前的传入的value。这个地方可能几个线程同时过来,但是redis本身天然是单线程的,所以getAndSet方法还是会安全执行,
            //首先执行的线程,此时curVal当然和oldVal值相等,因为就是同一个值,之后该线程set了自己的value,后面的线程就取不到锁了
            String oldVal = redisTemplate.opsForValue().getAndSet(key, value);
            if(StringUtils.isNotEmpty(oldVal) && oldVal.equals(curVal)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 解锁
     * @param key
     * @param value
     */
    public void unlock(String key, String value) {
        try {
            String curVal = redisTemplate.opsForValue().get(key);
            if (StringUtils.isNotEmpty(curVal) && curVal.equals(value)) {
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

redis单线程的,setIfAbsent方法在key存在的时候会返回false,而getAndSet则会设置新的值返回旧值,利用这几个特性即可实现多线程或者多进程的安全控制.