redis分布式锁之redisson

谁借莪１个温暖的怀抱￠ 2022-05-31 12:22 343阅读 0赞

## 概述： ##

关于 redisson详情请移步：[https://github.com/mrniko/redisson/wiki][https_github.com_mrniko_redisson_wiki]

下面通过简单的案例使用redisson的lock。  
1、RedissonManager类，管理redisson的初始化等操作。

public class RedissonManager { 
    
        private static final String RAtomicName = "genId_";
    
        private static Config config = new Config();
        private static Redisson redisson = null;
    
        public static void init(){
            try {
                config.useClusterServers() //这是用的集群server
                        .setScanInterval(2000) //设置集群状态扫描时间
                        .setMasterConnectionPoolSize(10000) //设置连接数
                        .setSlaveConnectionPoolSize(10000)
                        .addNodeAddress("127.0.0.1:6379","127.0.0.1:6380");
                redisson = Redisson.create(config);
                //清空自增的ID数字
                RAtomicLong atomicLong = redisson.getAtomicLong(RAtomicName);
                atomicLong.set(1);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    
        public static Redisson getRedisson(){
            return redisson;
        }
    
        /** 获取redis中的原子ID */
        public static Long nextID(){
            RAtomicLong atomicLong = getRedisson().getAtomicLong(RAtomicName);
            atomicLong.incrementAndGet();
            return atomicLong.get();
        }
    }

2、DistributedRedisLock类，提供锁和解锁方法

public class DistributedRedisLock {
        private static Redisson redisson = RedissonManager.getRedisson();
        private static final String LOCK_TITLE = "redisLock_";
    
        public static void acquire(String lockName){
            String key = LOCK_TITLE + lockName;
            RLock mylock = redisson.getLock(key);
            mylock.lock(2, TimeUnit.MINUTES); //lock提供带timeout参数，timeout结束强制解锁，防止死锁
            System.err.println("======lock======"+Thread.currentThread().getName());
        }
    
        public static void release(String lockName){
            String key = LOCK_TITLE + lockName;
            RLock mylock = redisson.getLock(key);
            mylock.unlock();
            System.err.println("======unlock======"+Thread.currentThread().getName());
        }
    }

测试代码：

private static void redisLock(){
            RedissonManager.init(); //初始化
            for (int i = 0; i < 100; i++) {
                Thread t = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            String key = "test123";
                            DistributedRedisLock.acquire(key);
                            Thread.sleep(1000); //获得锁之后可以进行相应的处理
                            System.err.println("======获得锁后进行相应的操作======");
                            DistributedRedisLock.release(key);
                            System.err.println("=============================");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                });
                t.start();
            }
        }

测试结果：

“\`  
======lock======Thread-91  
======获得锁后进行相应的操作======

# ======unlock======Thread-91 #

======lock======Thread-63  
======获得锁后进行相应的操作======

# ======unlock======Thread-63 #

======lock======Thread-31  
======获得锁后进行相应的操作======

# ======unlock======Thread-31 #

======lock======Thread-97  
======获得锁后进行相应的操作======

# ======unlock======Thread-97 #

======lock======Thread-8  
======获得锁后进行相应的操作======

# ======unlock======Thread-8 #

“\`