分布式锁Redission使用技巧

原创已于 2025-07-05 09:55:11 修改 · 1.1k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#分布式

于 2024-10-23 16:26:12 首次发布

Java 同时被 2 个专栏收录

33 篇文章

订阅专栏

NoSQL

21 篇文章

订阅专栏

一、基本概念

1、介绍

Redission是一个用于简化Redis操作的Java库‌。

‌核心功能‌：Redission提供了丰富的Redis操作接口，支持Redis的各种数据结构，如字符串、哈希、列表、集合、有序集合等，以及发布/订阅、事务、Lua脚本等高级功能。
‌特点‌：
- ‌易用性‌：Redission封装了Redis的底层实现，提供了更高级别的抽象，使得操作Redis更加简单方便。
- ‌扩展性‌：Redission支持分布式锁、分布式计数器、分布式映射等高级功能，可以满足更复杂的业务需求。
- ‌可靠性‌：Redission提供了连接池、自动重连等机制，增强了应用的可靠性和稳定性。
‌适用场景‌：Redission适用于需要高效、可靠地操作Redis的Java应用，特别是在需要实现分布式缓存、分布式会话、分布式锁等场景时。

总之，Redission是一个功能强大、易用可靠的Redis操作库，可以帮助开发者更高效地利用Redis。

2、核心

看门狗原理

如果线程 A 在等待的过程中，服务突然停了，那么锁会释放吗？如果不释放的话，就会成为死锁，阻塞了其他线程获取锁。
Redis中可以自定义设置key的过期时间，一般默认是30s

（1）默认指定锁时间为30s（看门狗时间）
（2）锁的自动续期：若是业务超长，运行期间自动给锁上新的 30s，不用担心业务时间过长，锁就自动过期
（3）加锁的业务只要运行完成，就不会给当前锁续期，即使不手动解锁，锁默认在30s 后自动删除。

二、代码实现

Redission分布式锁实现是一个基于Redis的Java驻内存数据网络解决方案，提供了丰富的分布式锁实现。以下是实现Redission分布式锁的基本步骤和代码示例

方式一：

1、引入依赖

<!-- Redisson 锁功能 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.2</version>
</dependency>

2、添加工具类

添加工具类RedisLock.java

 import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;

@Component
public class RedisLock
{
    @Autowired
    private RedissonClient redissonClient;
 
    /**
     * 获取锁
     *
     * @param lockKey 锁实例key
     * @return 锁信息
     */
    public RLock getRLock(String lockKey)
    {
        return redissonClient.getLock(lockKey);
    }
 
    /**
     * 加锁
     * 
     * @param lockKey 锁实例key
     * @return 锁信息
     */
    public RLock lock(String lockKey)
    {
        RLock lock = getRLock(lockKey);
        lock.lock();
        return lock;
    }
 
    /**
     * 加锁
     * 
     * @param lockKey 锁实例key
     * @param leaseTime 上锁后自动释放锁时间
     * @return true=成功；false=失败
     */
    public Boolean tryLock(String lockKey, long leaseTime)
    {
        return tryLock(lockKey, 0, leaseTime, TimeUnit.SECONDS);
    }
 
    /**
     * 加锁
     * 
     * @param lockKey 锁实例key
     * @param leaseTime 上锁后自动释放锁时间
     * @param unit 时间颗粒度
     * @return true=加锁成功；false=加锁失败
     */
    public Boolean tryLock(String lockKey, long leaseTime, TimeUnit unit)
    {
        return tryLock(lockKey, 0, leaseTime, unit);
    }
 
    /**
     * 加锁
     * 
     * @param lockKey 锁实例key
     * @param waitTime 最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @param unit 时间颗粒度
     * @return true=加锁成功；false=加锁失败
     */
    public Boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
    {
        RLock rLock = getRLock(lockKey);
        boolean tryLock = false;
        try
        {
            tryLock = rLock.tryLock(waitTime, leaseTime, unit);
        }
        catch (InterruptedException e)
        {
            return false;
        }
        return tryLock;
    }
 
    /**
     * 释放锁
     * 
     * @param lockKey 锁实例key
     */
    public void unlock(String lockKey)
    {
        RLock lock = getRLock(lockKey);
        lock.unlock();
    }
 
    /**
     * 释放锁
     * 
     * @param lock 锁信息
     */
    public void unlock(RLock lock)
    {
        lock.unlock();
    }
}

3、新增配置类

新增配置RedissonConfig.java

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig
{
    @Value("${spring.redis.host}")
    private String host;
 
    @Value("${spring.redis.port}")
    private String port;
 
    @Value("${spring.redis.password}")
    private String password;
 
    @Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean(RedissonClient.class)
    public RedissonClient redissonClient()
    {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port); // 更多.set
        return Redisson.create(config);
    }
}

4、代码调用

@Autowired
private RedisLock redisLock;
 
// lockKey 锁实例key waitTime 最多等待时间 leaseTime 上锁后自动释放锁时间  unit 时间颗粒度
redisLock.lock(lockKey);
redisLock.tryLock(lockKey, leaseTime);
redisLock.tryLock(lockKey, leaseTime, unit);
redisLock.tryLock(lockKey, waitTime, leaseTime, unit);
redisLock.unlock(lockKey);
redisLock.unlock(lock);

方式二：

1、引入依赖

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

2、自定义配置类

@Configuration
public class RedissonConfig {
    /**
     * 对 Redisson 的使用都是通过 RedissonClient 对象
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod="shutdown") // 服务停止后调用 shutdown 方法。
    public RedissonClient redisson() throws IOException {
        // 1.创建配置
        Config config = new Config();
        // 集群模式
        // config.useClusterServers().addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001");
        // 2.根据 Config 创建出 RedissonClient 示例。
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }
}

3、代码调用

@Controller
public class TestRedissonClient {
    @Autowired
    RedissonClient redisson;
 
    @ResponseBody
    @GetMapping("/hello")
    public String hello(){
        // 1、获取一把锁，只要锁的名字一样，既是同一把锁
        RLock lock = redisson.getLock ("my-lock");
 
        // 2、加锁
        lock.lock ();// 阻塞式等待
 
        try {
            System.out.println ("加锁成功，执行业务..."+Thread.currentThread ().getId () );
            // 模拟超长等待
            Thread.sleep (20000);
        } catch (Exception e) {
            e.printStackTrace ( );
        }finally {
            // 3、解锁
            System.out.println ("释放锁..."+Thread.currentThread ().getId () );
            lock.unlock ();
        }
        return "hello";
    }
}

加锁成功，执行业务...1
释放锁...1
加锁成功，执行业务...2
释放锁...2