Java操作Redis，使用Redis实现分布式锁

曾经终败给现在 2023-02-13 03:57 5阅读 0赞

### 目录 ###

*   *   *  jedis方式
         *   *  依赖
             *  使用jedis
             *  从jedis连接池获取连接
             *  连接redis集群
         *  spring data redis方式
         *   *  依赖
             *  yml
             *  工具类
         *  使用Redis实现分布式锁
         *   *  分布式锁需要解决的问题
             *  jedis方式
             *  spring data redis方式
         *  redisson
         *   *  基础方式
             *  redisson-spring-boot-starter方式
             *  实现分布式锁

java中操作redis常见的2个客户端

*  jedis：采用直连redis server的方式；提供了redis的基础操作。在多线程环境下，用于与redis服务器交互的Jedis对象非线程安全，线程需要从jedis连接池中获取jedis连接。
 *  Lettuce：网络通信基于netty，性能高；连接实例（StatefulRedisConnection）线程安全，可以被多个线程共同使用。

java中操作redis常用的3个类库

*  jedis：基于jedis客户端，常用于编写基础|公共类库
 *  spring data redis：基于Lettuce客户端，搭配spring使用十分方便
 *  redisson：以上2个都是关注redis的基础操作，redisson则关注redis的分布式操作，封装好了分布式的Lock、Semaphore、CountDownLatch、集合、队列等工具，对于分布式协调、开发十分方便。

### jedis方式 ###

#### 依赖 ####

<dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.3.0</version>
    </dependency>

#### 使用jedis ####

// 重载方法很多，可指定超时时间、是否使用ssl等
    Jedis jedis=new Jedis("192.168.1.9", 6379);
    
    // jedis.auth("xxxx"); //如果需要密码
    // jedis.select(0); //选择要使用的数据库
    
    if (jedis.ping().equals("PONG")){   //连接成功
        jedis.zadd("users", 1223, "zhangsan");
        jedis.zadd("users", 2568, "lisi");
        jedis.zadd("users", 1379, "wangwu");
    
        //迭代
        Set<Tuple> users = jedis.zrangeWithScores("users", 0, -1);  //[0,-1]
        for (Tuple user:users){ 
            String name = user.getElement(); //获取元素值
            double score = user.getScore(); //获取分数
            System.out.println(name+"的积分是："+score);
        }
    }
    else{ 
        System.out.println("无法连接redis服务器");
    }
    
    jedis.close();

#### 从jedis连接池获取连接 ####

// jedis连接池配置
    JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    jedisPoolConfig.setMaxTotal(15);
    jedisPoolConfig.setMaxIdle(10);
    jedisPoolConfig.setMinIdle(5);
    jedisPoolConfig.setMaxWaitMillis(180);//若一个Jedis对象闲置多少秒，就销毁
    
    // 重载方法很多，可指定超时时间、是否使用ssl、密码等
    JedisPool jedisPool= new JedisPool(jedisPoolConfig, "192.168.1.9", 6379);
    Jedis jedis = jedisPool.getResource();

#### 连接redis集群 ####

// 集群节点
    Set<HostAndPort> nodes = new HashSet();
    nodes.add(new HostAndPort("192.168.1.1", 6379));
    nodes.add(new HostAndPort("192.168.1.2", 6379));
    nodes.add(new HostAndPort("192.168.1.3", 6379));
    nodes.add(new HostAndPort("192.168.1.4", 6379));
    nodes.add(new HostAndPort("192.168.1.5", 6379));
    nodes.add(new HostAndPort("192.168.1.6", 6379));
    
    // 获取JedisCluster对象，通过JedisCluster对象来操作
    JedisCluster jedisCluster = new JedisCluster(nodes);
    
    String user = jedisCluster.get("user");
    
    jedisCluster.close();

### spring data redis方式 ###

#### 依赖 ####

创建springboot项目时勾选 NoSQL -> Spring Data Redis(Access+Driver)，或者手动添加依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

#### yml ####

spring:
      redis:
        #单机版redis配置，默认localhost、6379、0
        host: 192.168.1.1
        port: 6379
        database: 0
        #连接到redis服务器的超时时间，ms
        timeout: 3000
    
        #如果是redis集群，则使用以下配置
    # cluster:
    # nodes: 192.168.1.1:6379,192.168.1.2:6379,192.168.1.3:6379
    
        #jedis连接池配置
        jedis:
          pool:
            #默认8，-1表示不限制
            max-active: 200
            #默认0
            min-idle: 50
            #默认8
            max-idle: 100
            #如果jedis连接池没有闲置连接可用，最多等待多少ms
            max-wait: 3000

#### 工具类 ####

直接使用RedisTemplate提供的方法，一句代码要写很长，可以自己封装一下，使用时注入RedisUtil；也可以不封装，直接使用RedisTemplate

@Component
    public class RedisUtil { 
    
        @Autowired
        private static StringRedisTemplate redisTemplate;
    
        public static void set(String key,String value){ 
            redisTemplate.opsForValue().set(key,value);
        }
    
        public static String get(String key){ 
            return redisTemplate.opsForValue().get(key);
        }
    
        public static void hset(String key,String field,Object value { 
            redisTemplate.opsForHash().put(key,field,value);
        }
    
        public static Object hget(String key,String field){ 
            return redisTemplate.opsForHash().get(key,field);
        }
    
        //......
    
    }

### 使用Redis实现分布式锁 ###

#### 分布式锁需要解决的问题 ####

*  互斥性：同一时间段，只能有一个redis客户端获取到锁（持有锁）
 *  防止死锁：应该给key设置有效期，防止获取到锁的线程出现问题一直持有锁
 *  高性能：锁的粒度要小，比如读、写锁分开，尽可能减小锁住的范围
 *  可重入：同一个线程在获取到锁后，可以重复拿到同一个资源的锁

#### jedis方式 ####

setnx() 设置key

*  若返回1，说明设置成功，获取到锁；获取到锁后用expire() 给key设置有效期，预防发生故障锁不能及时释放
 *  若返回0，说明设置失败，这个key已经存在，锁已被其它线程持有，重试。重试可以用for循环来写，设置重试次数，失败时线程沉睡一小段时间，醒来继续循环、重试，如果达到指定次数还未获取到锁就退出循环、放弃

在任务执行过程中，如果发生异常，不能继续往下执行，也应该马上释放锁。任务完成后用del()删除key或者用expire()将有效期置为0，释放锁。

上面的方式分为setnx()、expire()2步，不满足原子性，可能出现2个问题

*  多线程下的并发操作问题
 *  执行完setnx后，由于宕机、网络故障等原因导致expire执行失败

更好的方式：使用redis命令的原子性

#ex指定过期时间（s），px也是指定过期时间（ms），nx是key不存在时才执行set（即新建），xx表示key已存在时才执行set（即更新）
    set lock "xxxxxxx" ex 60 nx
    
    
    // jedis
    jedis.set("lock", "xxxxxx", SetParams.setParams().ex(120).nx());

值一般设置为线程号

#### spring data redis方式 ####

对应的方法如下

// 设置key，absent，缺席、不存在，返回布尔值
    Boolean redisTemplate.opsForValue().setIfAbsent(key，value)     
    // 设置有效期，key、数值、单位
    redisTemplate.expire(key，2，TimeUnit.MINUTES)
    
    // 更好的写法，原子性
    Boolean redisTemplate.opsForValue().setIfAbsent(key，value，2，TimeUnit.MINUTES)    
    
    // 删除key
    redisTemplate.delete(key)

### redisson ###

#### 基础方式 ####

依赖

<dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.16.1</version>
    </dependency>

获取RedissonClient

/** * 获取本地单机版redis的 RedissonClient */
    public static RedissonClient getRedissonClientForLocalServer() { 
        //不指定config，默认为 127.0.0.1:6379
        return Redisson.create();
    }
    
    /** * 获取单机版redis的 RedissonClient */
    public static RedissonClient getRedissonClientForSingleServer() { 
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
    
    /** * 获取redis集群的 RedissonClient */
    public static RedissonClient getRedissonClient() { 
        Config config = new Config();
        config.useReplicatedServers().addNodeAddress("redis://127.0.0.1:6377", "redis://127.0.0.1:6378", "redis://127.0.0.1:6379");
        return Redisson.create(config);
    }

*  config都可以使用set指定密码、使用的库，默认不需要密码、使用db0
 *  redis://127.0.0.1:6379，地址可以以redis开头，也可以rediss开头，第二个s表示使用ssl安全通信，服务器通常都部署在内网中，使用redis即可。

配置项可参考：[https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95][https_github.com_redisson_redisson_wiki_2.-_E9_85_8D_E7_BD_AE_E6_96_B9_E6_B3_95]

#### redisson-spring-boot-starter方式 ####

依赖

<dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.16.1</version>
    </dependency>

这个依赖中已经包含了redisson的基础依赖、spring data redis的依赖，所以基础方式、spring data redis也是可以直接用的。

yml

spring:
      redis:
        #单机版redis配置，默认localhost、6379、0
        host: 182.61.45.66
        port: 6379
        database: 0
        #连接到redis服务器的超时时间，ms
        timeout: 3000
    
        #如果是redis集群，则使用以下配置
        # cluster:
        # nodes: 192.168.1.1:6379,192.168.1.2:6379,192.168.1.3:6379
    
        #jedis连接池配置
        jedis:
          pool:
            #默认8，-1表示不限制
            max-active: 200
            #默认0
            min-idle: 50
            #默认8
            max-idle: 100
            #如果jedis连接池没有闲置连接可用，最多等待多少ms
            max-wait: 3000

使用spring data redis的配置即可。

可以直接注入使用 RedisTemplate、RedissonClient 这2个bean。

更多配置可参考：[https://github.com/redisson/redisson/blob/master/redisson-spring-boot-starter/README.md][https_github.com_redisson_redisson_blob_master_redisson-spring-boot-starter_README.md]

#### 实现分布式锁 ####

//参数指定key的名称，这个key会作为锁，在释放锁时会被删除，所以不要指定为有其它作用的key，应该用专门的key作为锁
    RLock rLock = redissonClient.getLock("xxx");
    //尝试获取锁，对应的key创建成功意味着获取到锁，会一直阻塞在这里直到获取到锁
    rLock.lock();
    try { 
        //使用共享资源
    } finally { 
        //释放锁，释放时会自动删除作为锁的key
        rLock.unlock();
    }

可以指定锁的类型

//可重入锁（Reentrant Lock）
    RLock reentrantLock = redissonClient.getLock("xxx");
    
    //公平锁
    RLock fairLock = redissonClient.getFairLock("xxx");
    
    //读写锁
    RReadWriteLock rwLock = redissonClient.getReadWriteLock("xxx");
    //获取读锁
    rwlock.readLock().lock();
    //获取写锁
    rwlock.writeLock().lock();

获取锁的几种方法

//获取不到锁时会一直阻塞线程；获取到锁后如果出现问题不会释放锁，可能导致死锁
    rLock.lock();
    
    //2个参数指定释放锁的超时时间，如果获取到锁后在指定时间内未释放锁，会自动释放
    rLock.lock(3, TimeUnit.MINUTES);
    
    //第1个参数指定获取锁的超时时间，第2个参数指定释放锁的超时时间，返回值表示是否获取到锁
    //如果在指定的时间内未获取到锁，直接返回false，不再阻塞线程
    boolean result = rLock.tryLock(5, 3, TimeUnit.MINUTES);

一般使用后2种，不使用无参的lock()。

redisson实现分布式锁的原理

> 加锁：尝试获取锁，创建key成功说明获取到锁；如果key已存在获取锁失败，则订阅锁释放的消息，并阻塞线程，接收到锁释放的通知后再次尝试获取锁。key是hash类型。  
>   
> 释放锁：使用完共享资源后删除key，删除key即释放锁。

redisson实现分布式锁存在的问题

> 在redis集群模式下，如果创建key成功、获取到锁，但在尚未同步到任何一个slave时master宕机，选举一个slave作为master，此时新master上不存在对应的key，其它线程依然可以创建key成功、获取到锁，可能存在多个线程获取到同一把锁的情况。

redisson的更多分布式操作可参考

[https://github.com/redisson/redisson/wiki/8.-%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81%E5%92%8C%E5%90%8C%E6%AD%A5%E5%99%A8][https_github.com_redisson_redisson_wiki_8.-_E5_88_86_E5_B8_83_E5_BC_8F_E9_94_81_E5_92_8C_E5_90_8C_E6_AD_A5_E5_99_A8]

[https://blog.csdn.net/qq\_25582465/article/details/109309624][https_blog.csdn.net_qq_25582465_article_details_109309624]

[https_github.com_redisson_redisson_wiki_2.-_E9_85_8D_E7_BD_AE_E6_96_B9_E6_B3_95]: https://github.com/redisson/redisson/wiki/2.-%E9%85%8D%E7%BD%AE%E6%96%B9%E6%B3%95
[https_github.com_redisson_redisson_blob_master_redisson-spring-boot-starter_README.md]: https://github.com/redisson/redisson/blob/master/redisson-spring-boot-starter/README.md
[https_github.com_redisson_redisson_wiki_8.-_E5_88_86_E5_B8_83_E5_BC_8F_E9_94_81_E5_92_8C_E5_90_8C_E6_AD_A5_E5_99_A8]: https://github.com/redisson/redisson/wiki/8.-%E5%88%86%E5%B8%83%E5%BC%8F%E9%94%81%E5%92%8C%E5%90%8C%E6%AD%A5%E5%99%A8
[https_blog.csdn.net_qq_25582465_article_details_109309624]: https://blog.csdn.net/qq_25582465/article/details/109309624