redis实现分布式锁实现redisson

生产环境中的分布式锁实现

加入jar包的依赖
 

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

配置Redisson
 

package com;

import org.redisson.Redisson;
import org.redisson.config.Config;

/**
 * @author wangbh
 * @Description: test
 * @date 2021/8/19 10:44
 */
public class RedissonManager {
    private static Config config = new Config();
    //声明redisso对象
    private static Redisson redisson = null;

    //实例化redisson
    static {
        //单个
        config.useSingleServer().setPassword("!QAZxsw2#EDC(0Ol1)")
                .setAddress("192.168.1.239:6379").setDatabase(2);
        //        config.useClusterServers()
         集群状态扫描间隔时间，单位是毫秒
        //                .setScanInterval(2000)
        cluster方式至少6个节点(3主3从，3主做sharding，3从用来保证主宕机后可以高可用)
        //                .addNodeAddress("192.168.1.239:6379").setPassword("!QAZxsw2#EDC(0Ol1)");
        //得到redisson对象
        redisson = (Redisson) Redisson.create(config);
    }

    //获取redisson对象的方法
    public static Redisson getRedisson() {
        return redisson;
    }
}

锁的获取和释放
 

package com;

import org.redisson.Redisson;
import org.redisson.api.RLock;

import java.util.concurrent.*;

/**
 * @author wangbh
 * @Description: TEST
 * @date 2021/8/19 10:46
 */
public class DistributedRedisLock {
    //从配置类中获取redisson对象
    private static Redisson redisson = RedissonManager.getRedisson();
    private static final String LOCK_TITLE = "redisLock_";

    //加锁
    public static boolean acquire(String lockName) {
//声明key对象业务逻辑中使用分布式锁Redisson分布式锁的实现原理
        String key = LOCK_TITLE + lockName;
//获取锁对象
        RLock mylock = redisson.getLock(key);
        if(!mylock.tryLock()){
            return false;
        }
//加锁，并且设置锁过期时间3秒，防止死锁的产生 uuid+threadId
        //mylock.lock( 3, TimeUnit.SECONDS);
//加锁成功
        return true;
    }

    //锁的释放
    public static void release(String lockName) {
//必须是和加锁时的同一个key
        String key = LOCK_TITLE + lockName;
//获取所对象
        RLock mylock = redisson.getLock(key);
//释放锁（解锁）
        mylock.unlock();
    }
}

业务逻辑中使用分布式锁
 

package com;

import java.util.ArrayList;
import java.util.List;

/**
 * @author wangbh
 * @Description: test
 * @date 2021/8/19 10:43
 */
public class RedisLock {
    static String key = "test123";
    static   int cnt=100;
    static class MyThread implements Runnable {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                while (!DistributedRedisLock.acquire(key)) {
                    System.out.println(Thread.currentThread().getName() +":"+Thread.currentThread().getId() + ":no");
                    Thread.sleep(10000);
                }
                cnt--;
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getId() + ":yes:"+cnt);
                Thread.sleep(10000);
                DistributedRedisLock.release(key);
                System.out.println(Thread.currentThread().getName() +":"+Thread.currentThread().getId() +":release");
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }

    public static void main(String[] args) {
        List<Thread> list = new ArrayList<>();
        for (int index = 0; index < 10; index++) {
            Thread thread = new Thread(new MyThread());
            list.add(thread);
            thread.start();
        }
        list.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("Now all thread done!");
        System.exit(0);
    }

}

Redisson分布式锁的实现原理