2024年最全基于zookeeper实现分布式锁_zk实现分布式锁(3)，理论+实战双管齐下

本文链接：https://blog.youkuaiyun.com/2401_84183628/article/details/138833669

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

        e.printStackTrace();
    }
}

@PreDestroy
public void destroy() {
    if (zooKeeper != null) {
        try {
            zooKeeper.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 初始化分布式对象方法
 */
public ZkDistributedLock getZkDistributedLock(String lockname){
    return new ZkDistributedLock(zooKeeper,lockname);
}

}


#### 代码落地

public class ZkDistributedLock {
public static final String ROOT_PATH = “/distribute”;
private String path;
private ZooKeeper zooKeeper;

public ZkDistributedLock(ZooKeeper zooKeeper, String lockname) {
    this.zooKeeper = zooKeeper;
    this.path = ROOT_PATH + "/" + lockname;
}

public void lock() {
    try {
        zooKeeper.create(path, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
    } catch (KeeperException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    try {
        Thread.sleep(200);
        lock();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

public  void  unlock(){
    try {
        this.zooKeeper.delete(path,0);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (KeeperException e) {
        e.printStackTrace();
    }

}

}


改造StockService的checkAndLock方法：

@Autowired
private zkClient client;

public void checkAndLock() {
    // 加锁，获取锁失败重试
    ZkDistributedLock lock = this.client.getZkDistributedLock("lock");
    lock.lock();
    // 先查询库存是否充足
    Stock stock = this.stockMapper.selectById(1L);
    // 再减库存
    if (stock != null && stock.getCount() > 0) {
        stock.setCount(stock.getCount() - 1);
        this.stockMapper.updateById(stock);
    }
    lock.unlock();
}


Jmeter压力测试：


![](https://img-blog.csdnimg.cn/8aa545c33a5c48468a6181d2f2760799.png) 性能一般，mysql数据库的库存余量为0（注意：所有测试之前都要先修改库存量为5000）


基本实现存在的问题：  
        1. 性能一般（比mysql略好）  
         2. 不可重入  
 接下来首先来提高性能


### 优化：性能优化


基本实现中由于无限自旋影响性能：


![](https://img-blog.csdnimg.cn/336c29e5647b4f8b944346a19b6e093b.png)


试想：每个请求要想正常的执行完成，最终都是要创建节点，如果能够避免争抢必然可以提高性能。这里借助于zk的临时序列化节点，实现分布式锁： 


![](https://img-blog.csdnimg.cn/917c7808d3964faba179c26073730783.png)


####  实现阻塞锁


代码实现：

public class ZkDistributedLock {
public static final String ROOT_PATH = “/distribute”;
private String path;
private ZooKeeper zooKeeper;

public ZkDistributedLock(ZooKeeper zooKeeper, String lockname) {
    this.zooKeeper = zooKeeper;
    try {
        this.path = zooKeeper.create(ROOT_PATH + "/" + lockname + "_",
                null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (KeeperException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public void lock() {
    String preNode = getpreNode(path);
    //如果该节点没有前一个节点，说明该节点是最小的节点
    if (StringUtils.isEmpty(preNode)) {
        return;
    }
    //重新检查是否获取到锁
    try {
        Thread.sleep(20);
        lock();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

/**
 * 获取指定节点的前节点
 *
 * @param path
 * @return
 */
private String getpreNode(String path) {
    //获取当前节点的序列化序号
    Long curSerial = Long.valueOf(StringUtil.substringAfter(path, '_'));
    //获取根路径下的所有序列化子节点
    try {
        List<String> nodes = this.zooKeeper.getChildren(ROOT_PATH, false);
        //判空处理
        if (CollectionUtils.isEmpty(nodes)) {
            return null;
        }
        //获取前一个节点
        Long flag = 0L;
        String preNode = null;
        for (String node : nodes) {
            //获取每个节点的序列化号
            Long serial = Long.valueOf(StringUtil.substringAfter(path, '_'));
            if (serial < curSerial && serial > flag) {
                flag = serial;
                preNode = node;
            }
        }
        return preNode;
    } catch (KeeperException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return null;
}

public void unlock() {
    try {
        this.zooKeeper.delete(path, 0);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (KeeperException e) {
        e.printStackTrace();
    }

}

}


主要修改了构造方法和lock方法：


![](https://img-blog.csdnimg.cn/09a53e16299e4e8bba80339f58e95215.png)


 并添加了getPreNode获取前置节点的方法。


测试结果如下：


![](https://img-blog.csdnimg.cn/bf90b8602a884e15862dbde4c939adfa.png)


 性能反而更弱了。


原因：虽然不用反复争抢创建节点了，但是会自选判断自己是最小的节点，这个判断逻辑反而更复杂更 耗时。


解决方案：监听实现阻塞锁


#### 监听实现阻塞锁


对于这个算法有个极大的优化点：假如当前有1000个节点在等待锁，如果获得锁的客户端释放锁时，这1000个客户端都会被唤醒，这种情况称为“羊群效应”；在这种羊群效应中，zookeeper需要通知1000个 客户端，这会阻塞其他的操作，最好的情况应该只唤醒新的最小节点对应的客户端。应该怎么做呢？在 设置事件监听时，每个客户端应该对刚好在它之前的子节点设置事件监听，例如子节点列表 为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002，序号为1的客户端监听 序号为0的子节点删除消息，序号为2的监听序号为1的子节点删除消息。


所以调整后的分布式锁算法流程如下：


* 客户端连接zookeeper，并在/lock下创建临时的且有序的子节点，第一个客户端对应的子节点 为/lock/lock-0000000000，第二个为/lock/lock-0000000001，以此类推；
* 客户端获取/lock下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子 节点，如果是则认为获得锁，否则监听刚好在自己之前一位的子节点删除消息，获得子节点变更通 知后重复此步骤直至获得锁；
* 执行业务代码；
* 完成业务流程后，删除对应的子节点释放锁。


改造ZkDistributedLock的lock方法：

public void lock() {
    String preNode = getpreNode(path);
    //如果该节点没有前一个节点，说明该节点是最小的节点
    if (StringUtils.isEmpty(preNode)) {
        return;
    } else {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        try {
            if (this.zooKeeper.exists(ROOT_PATH + "/" + preNode, watchedEvent -> {
                countDownLatch.countDown();
            }) == null) {
                return;
            }
            countDownLatch.await();
            return;

        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock();
    }
}


压力测试效果如下：


![](https://img-blog.csdnimg.cn/4447f4f71bab4224a2d71fa4123a2c6a.png)


 由此可见性能提高不少仅次于redis的分布式锁


### 优化：可重入锁


引入ThreadLocal线程局部变量保证zk分布式锁的可重入性。


在对应的线程的存储数据

public class ZkDistributedLock {
public static final String ROOT_PATH = “/distribute”;
private String path;
private ZooKeeper zooKeeper;
private static final ThreadLocal THREAD_LOCAL = new ThreadLocal<>();

public ZkDistributedLock(ZooKeeper zooKeeper, String lockname) {
    this.zooKeeper = zooKeeper;
    try {
        this.path = zooKeeper.create(ROOT_PATH + "/" + lockname + "_",
                null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (KeeperException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

public void lock() {
    Integer flag = THREAD_LOCAL.get();
    if (flag != null && flag > 0) {
        THREAD_LOCAL.set(flag + 1);
        return;
    }
    String preNode = getpreNode(path);
    //如果该节点没有前一个节点，说明该节点是最小的节点
    if (StringUtils.isEmpty(preNode)) {
        return;
    } else {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        try {
            if (this.zooKeeper.exists(ROOT_PATH + "/" + preNode, watchedEvent -> {
                countDownLatch.countDown();
            }) == null) {
                return;
            }
            countDownLatch.await();
            THREAD_LOCAL.set(1);
            return;

        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock();
    }
}

/**
 * 获取指定节点的前节点
 *
 * @param path
 * @return
 */
private String getpreNode(String path) {
    //获取当前节点的序列化序号
    Long curSerial = Long.valueOf(StringUtil.substringAfter(path, '_'));
    //获取根路径下的所有序列化子节点
    try {
        List<String> nodes = this.zooKeeper.getChildren(ROOT_PATH, false);
        //判空处理
        if (CollectionUtils.isEmpty(nodes)) {
            return null;
        }
        //获取前一个节点
        Long flag = 0L;
        String preNode = null;
        for (String node : nodes) {
            //获取每个节点的序列化号
            Long serial = Long.valueOf(StringUtil.substringAfter(path, '_'));
            if (serial < curSerial && serial > flag) {
                flag = serial;
                preNode = node;
            }
        }
        return preNode;
    } catch (KeeperException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return null;
}

public void unlock() {
    try {
        THREAD_LOCAL.set(THREAD_LOCAL.get() - 1);
        if (THREAD_LOCAL.get() == 0) {
            this.zooKeeper.delete(path, 0);
            THREAD_LOCAL.remove();
        }

    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (KeeperException e) {
        e.printStackTrace();
    }

}

}



![img](https://img-blog.csdnimg.cn/img_convert/0e65ca5edf57413262d82b6ec3bb01c5.png)
![img](https://img-blog.csdnimg.cn/img_convert/d37ecdb3a14bffd0c4bc51c796627b81.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.youkuaiyun.com/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

e();
        } catch (KeeperException e) {
            e.printStackTrace();
        }

    }
}

[外链图片转存中…(img-pUQQjtAp-1715640213992)]
[外链图片转存中…(img-eNKfHmmk-1715640213992)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取