同一服务在单实例部署环境可通过synchronized、ReentrantLock本地锁来保证在一次只能允许一个线程执行被锁住的代码块，但在分布式多实例部署环境需实现分布式锁来保证互斥性。redisson堪称redis分布式锁最完美实现。在这里我先举个例子,先不去考虑实现原理先

一、引入依赖

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

二、代码实现

用redis来实现分布式锁，代码实现很简单如下：

Config config = new Config();
//集群模式
config.useClusterServers()
    .setScanInterval(2000) // cluster state scan interval in milliseconds
    .addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001")
    .addNodeAddress("redis://127.0.0.1:7002");

//单机模式
//config.useSingleServer().setAddress("redis://192.168.157.6:6379");
//RedissonClient redission = Redisson.create(config);

RedissonClient redisson = Redisson.create(config);

RLock lock = redisson.getLock("anyLock");

lock.lock();

try {
    ...
} finally {
    lock.unlock();
}

三、多线程计数

通常分布式锁的应用是在多个进程之间，如果是线程之间就直接用Java的同步锁就可以了，但是这里我直接用多线程计数的例子来试试Redisson的锁能不能锁住，代码如下：

public class RedissionTest {
    static int j = 0;
    static RLock lock = null;

    /**
     *     初始化
     */
    public static void initLock() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.157.6:6379");
        RedissonClient redission = Redisson.create(config);
        lock = redission.getLock("MyLock");
    }
    /**
     * 加锁
     */
    public static void lock() {
        lock.lock();
    }
    /**
     * 解锁
     */
    public static void unLock() {
        lock.unlock();
    }
    public static void main(String[] args) {
        //初始化锁
        initLock();
        //模拟启动5个线程
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                public void run() {
                    try {
                        lock.lock();
                        System.out.println("线程："+Thread.currentThread().getId()+"获得锁，开始处理业务流程...");
                        try {
                            //模拟业务逻辑执行3秒
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        j++;
                        System.out.println("当前的j=" + j);
                    } finally {
                        System.out.println("线程："+Thread.currentThread().getId()+"释放锁。");
                        unLock();
                    }
                }
            }).start();
        }
    }

}

运行输出结果

线程：22获得锁，开始处理业务流程...
当前的j=1
线程：22释放锁。
线程：20获得锁，开始处理业务流程...
当前的j=2
线程：20释放锁。
线程：23获得锁，开始处理业务流程...
当前的j=3
线程：23释放锁。
线程：21获得锁，开始处理业务流程...
当前的j=4
线程：21释放锁。
线程：24获得锁，开始处理业务流程...
当前的j=5
线程：24释放锁。

可以看到，是有锁的效果的。

四、模拟两个进程

这里模拟一下两个进程执行，一个进程执行获得锁后休眠20秒，另一个进程再执行看看是否需要等待，因为这里不是同时执行的，中间要一个个进程启动并且还要算上网络连接的时间，所以第二个线程只要等上了八九秒就表明OK了。

1、进程1

public class RedissionTest2 {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.157.6:6379");
        RedissonClient redission = Redisson.create(config);
        RLock lock = redission.getLock("MyLock");
        lock.lock();
        try {
            System.out.println("进程1执行业务逻辑20秒钟。。。");
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            lock.unlock();
            System.out.println("进程1执行完成。。。");
        }

    }

}

2、进程2

public class RedissionTest3 {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.157.6:6379");
        RedissonClient redission = Redisson.create(config);
        RLock lock = redission.getLock("MyLock");
        System.out.println("进程2开始执行业务逻辑。。。。");
        Long start = System.currentTimeMillis();
        lock.lock();
        try {
            System.out.println("进程2获得锁执行业务逻辑");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            lock.unlock();
            Long end = System.currentTimeMillis();
            System.out.println("进程2执行业务逻辑完成，耗时："+(end-start)+"毫秒");
        }

    }

}

3、运行测试

这里先运行进程1，可以看到打印了

进程1执行业务逻辑20秒钟。。。

然后我们执行进程2（这里已经耗费了几秒钟），打印如下日志

进程2开始执行业务逻辑。。。。

20秒后，进程1执行完了，可以看到日志

进程1执行业务逻辑20秒钟。。。
进程1执行完成。。。

然后进程2获得锁，执行完业务逻辑，可以看到日志

进程2开始执行业务逻辑。。。。
进程2获得锁执行业务逻辑
进程2执行业务逻辑完成，耗时：15844毫秒

可以看到，除开启动和网络连接时间，两个进程有做同步。