Redis setnx方式设置分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel保证高可用，如果master节点由于某些原因发生了主从切换，那么就会出现锁丢失的情况：
1.客户端1在Redis的master节点上拿到了锁。
2.Master宕机了，存储锁的key还没有来得及同步到Slave上。
3.master故障，发生故障转移，slave节点升级为master节点。
4.客户端2从新的Master获取到了对应同一个资源的锁。
于是，客户端1和客户端2同时持有了同一个资源的锁。锁的安全性被打破了。

老师，我试了一下redisson实现的分布式锁。有两个问题请教您。
1 .redis的集群模式，我在一台机器上建了一个伪集群。创建集群时，一共6个节点。3主3从。从节点是自动分配的。从节点的只读模式需要改成no吗?(不改成no，往从节点写锁，就会转移到主节点上去)
2 .字数限制，没办法贴代码，我在您例子的基础上增加了3个节点，也就是6个节点。核心代码如下：
final long waitTimeout = 10;
        final long leaseTime = 3;
final RLock lock1 = redissonClient1.getLock("lock1");
        final RLock lock2 = redissonClient2.getLock("lock2");
        final RLock lock3 = redissonClient3.getLock("lock3");
        final RLock lock4 = redissonClient4.getLock("lock4");
        final RLock lock5 = redissonClient5.getLock("lock5");
        final RLock lock6 = redissonClient6.getLock("lock6");

for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3, lock4, lock5, lock6);
                    try {
                        if (redLock.tryLock(waitTimeout, leaseTime, TimeUnit.SECONDS)) {
                            //业务逻辑
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        redLock.unlock();
                    }
                }
            }).start();
        }
使用6个节点来实现redisson，但是获取锁一直失败，怎么回事呢？老师

老师，我试了一下zookeeper的集群分布式锁。测试代码如下：
public class TestZookeeperLock {
    private static int count = 10;

    public static void main(String[] args) {
        //重试策略,以下写法为:重试3次，每次间隔时间为3秒
        final RetryPolicy retryPolicy = new RetryNTimes(3,2000);
        final String connUrl = "192.111.111.111:2181,192.222.222.222:2181";
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //zookeeper分布式锁
                    CuratorFramework zk = CuratorFrameworkFactory.newClient(connUrl, retryPolicy);
                    zk.start();
                    InterProcessMutex lock = new InterProcessMutex(zk, "/opt/uams/zookeeper-3.4.7/locks");
                    try {
                        if (lock.acquire(3, TimeUnit.SECONDS)){
                            get();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            //释放锁
                            lock.release();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
    }

    public static void get (){
        count --;
        if (count == 3) {
            try {
                TimeUnit.SECONDS.sleep(3);//这里设置该线程睡眠2秒,已达到锁住效果
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(count);
    }
}
输出了：
9
8
7
6
5
4
java.lang.IllegalMonitorStateException: You do not own the lock: /opt/uams/zookeeper-3.4.7/locks
    at org.apache.curator.framework.recipes.locks.InterProcessMutex.release(InterProcessMutex.java:140)
    at cn.org.test.TestZookeeperLock$1.run(TestZookeeperLock.java:47)
    at java.lang.Thread.run(Thread.java:745)
3
多次输出的结果一致，这是怎么回事呢?

1.锁超时，也会出现多个任务同时持有锁进行。
2.解决方式，守护线程续航锁持有时间。
3.弊端，浪费线程，开销太大。
4.根据业务情况设置合理的超时时间是最棒的。

5.集群环境还会导致事务失效（同时提交多个key，多个key在不同节点）挺蛋疼。