当前位置: 首页>后端>正文

Redis分布式锁的实现代码示例

上一篇 <<<Redis实现分布式锁的原理分析
下一篇 >>>使用Redisson工具实现分布式锁

单机环境下的分布式锁类

public class JaryeRedisLock {

    private static final int setnxSuccss = 1;
    /**
     * 获取锁
     *
     * @param lockKey        定义锁的key
     * @param notLockTimeOut 没有获取锁的超时时间
     * @param lockTimeOut    使用锁的超时时间
     * @return
     */
    public String getLock(String lockKey, int notLockTimeOut, int lockTimeOut) {
        // 获取Redis连接
        Jedis jedis = RedisUtil.getJedis();
        // 定义没有获取锁的超时时间
        Long endTimeOut = System.currentTimeMillis() + notLockTimeOut;
        while (System.currentTimeMillis() < endTimeOut) {
            String lockValue = UUID.randomUUID().toString();
            // 如果在多线程情况下谁能够setnx 成功返回0 谁就获取到锁
            if (jedis.setnx(lockKey, lockValue) == setnxSuccss) {
                jedis.expire(lockKey, lockTimeOut / 1000);
                return lockValue;
            }
            // 否则情况下 在超时时间内继续循环
        }
        try {
            if (jedis != null) {
                jedis.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 释放锁 其实就是将该key删除
     *
     * @return
     */
    public Boolean unLock(String lockKey, String lockValue) {
        Jedis jedis = RedisUtil.getJedis();
        // 确定是对应的锁 ,才删除
        if (lockValue.equals(jedis.get(lockKey))) {
            return jedis.del(lockKey) > 0 true : false;
        }
        return false;
    }
}
public class OrderService {

    private JaryeRedisLock jaryeRedisLock = new JaryeRedisLock();
    private String lockKey = "jarye_lock";

    public void service() {
        // 1.获取锁
        String lockValue = jaryeRedisLock.getLock(lockKey, 1000, 1000);
        if (StringUtils.isEmpty(lockValue)) {
            System.out.println(Thread.currentThread().getName() + ",获取锁失败!");
            return;
        }
        // 2.获取锁成功执行业务逻辑
        System.out.println(Thread.currentThread().getName() + ",获取成功,lockValue:" + lockValue);
//        // 3.释放lock锁
        jaryeRedisLock.unLock(lockKey, lockValue);
    }

    public static void main(String[] args) {
        OrderService service = new OrderService();
        service.service();
        System.out.println("程序已完結");
    }
}

集群环境下的分布式锁类

集群环境下的IP和端口可以直接配置一个,JedisCluster实例时会自动寻址找到所有信息

public class DistributedLockUtil 
{ 
    private static final String LOCK_SUCCESS = "OK"; 
    private static final String SET_IF_NOT_EXIST = "NX"; 
    private static final String SET_WITH_EXPIRE_TIME = "PX"; 
    private static final Long RELEASE_SUCCESS = 1L; 

    /** 
     * 尝试获取分布式锁
     * @param jd RedisCluster客户端 
     * @param lockKey 锁 
     * @param requestId 请求标识 
     * @param expireTime 超期时间 
     * @return 是否获取成功 
     */
    public static boolean tryGetDistributedLock(JedisCluster jd, String lockKey, String requestId, int expireTime) 
    { 

        String result = jd.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime); 

        if (LOCK_SUCCESS.equals(result)) 
        { 
            return true; 
        } 
        return false; 
    } 



    /** 
     * 释放分布式锁
     * @param jd RedisCluster客户端 
     * @param lockKey 锁 
     * @param requestId 请求标识 
     * @return 是否释放成功 
     */
    public static boolean releaseDistributedLock(JedisCluster jd, String lockKey, String requestId) 
    { 
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"; 
        Object result = jd.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId)); 

        if (RELEASE_SUCCESS.equals(result)) 
        { 
            return true; 
        } 
        return false; 
    } 
} 

Springboot下使用分布式锁

//分布式锁使用时一般这么写:
a、获得锁
b、如果未获得锁则友好提示
try{
    c、业务逻辑
}finally{
    d、释放锁
}
  • 影响锁的效率:

1、key是全局唯一的
2、锁的粒度

  • 如何提高分布式锁的效率:

1、降低锁的粒度
a、上面b步骤放在try的外面
b、业务逻辑代码尽可能的简单
2、不同的业务使用不同的锁,不要全部用同一把锁

  • 集群情况下,使用redisTemplate.opsForCluster()
public class RedisLockUtil {

    /**
     * 可以使用SpringUtils.getBean(StringRedisTemplate.class);获得bean
     */
    private StringRedisTemplate redisTemplate =null;
    /**
     * 分布式锁名称
     */
    private String lockName;
    /**
     * 超时时间
     */
    private int timeOut = 30;
    /**
     * 看门狗线程,可以给分布式锁续期,用于解决业务还没完成,但分布式锁已到期了【缺点:业务死锁,会导致永远获取不了当前锁】
     */
    private Thread threadDog;
    /**
     * 本地变量,保证获得锁和释放锁是同一个线程
     */
    private static ThreadLocal threadLocal = new InheritableThreadLocal();

    private RedisLockUtil(String lockName) {
        this.lockName = lockName;
    }

    /**
     * 获得实例
     */
    public static RedisLockUtil getRedisLock(String lockName) {
        return new RedisLockUtil(lockName);
    }

    /**
     * 上锁
     * @return
     */
    public Boolean lock() {
        String value = UUID.randomUUID().toString();
        boolean store = redisTemplate.opsForValue().setIfAbsent(lockName,value);
        if(store){
            //设置过期时间,防止程序死循环导致锁无法释放
            redisTemplate.expire(lockName,timeOut,TimeUnit.SECONDS);
            threadLocal.set(value);
            dogMonitorStart();
        }
        return store;
    }

    private void dogMonitorStart() {
        threadDog = new Thread(()->{
            while (true) {
                String uuid = (String)threadLocal.get();
                if(StringUtils.isBlank(uuid)){
                    return;
                }
                boolean flg = redisTemplate.expire(lockName, timeOut, TimeUnit.SECONDS);
                if(!flg){
                    break;
                }
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        threadDog.start();
    }

    /**
     * 释放锁
     */
    public void unlock() {
        String s = redisTemplate.opsForValue().get(lockName);
        if(((String)threadLocal.get()).equals(s)) {
            redisTemplate.delete(lockName);
            threadDog.stop();
            threadLocal.remove();
        }
    }
}

推荐阅读:
<<<分布式缓存与本地缓存的区别
<<<Ehcache基础知识
<<<SpringBoot整合Ehcache
<<<Redis的5种数据类型
<<<Redis存放实体对象的方式及区别
<<<Redis的应用场景汇总
<<<Redis高效及线程安全的真正原因
<<<Redis为啥要分为16个库
<<<RDB和AOF持久化方式的区别
<<<Redis与数据库的一致性解决方案
<<<SpringBoot整合Redis的注解版本完成数据缓存
<<<Redis的淘汰策略
<<<Redis的事务操作(Mult和Watch)知识点
<<<Redis的过期机制使用场景示例
<<<Redis实现分布式锁的原理分析
<<<使用Redisson工具实现分布式锁
<<<Redis集群模式之主从复制原理及存在的缺陷
<<<Redis集群模式之哨兵模式
<<<Redis集群模式之Cluster去中心化分片集群
<<<Linux环境下安装单机Redis
<<<Redis Cluster集群环境搭建
<<<Redis Cluster如何动态扩容与缩容
<<<Redis Cluster主从节点自动切换
<<<Redis集群模式的类型和缺陷汇总
<<<Redis缓存的穿透、击穿和雪崩效应
<<<Redis解决穿透击穿问题时使用的布隆过滤器知识点
<<<Redis与MySQL的数据同步解决方案
<<<阿里云的Canal框架实现Redis与Mysql同步原理及代码示例
<<<阿里云的Canal框架配置
<<<Redis官方提出的redlock分布式锁
<<<Redis的调优设置
<<<Redis常见问题汇总


https://www.xamrdz.com/backend/3xz1920655.html

相关文章: