基于Zookeeper实现分布式锁

一 什么是Zookeeper

ZooKeeper致力于为分布式应用提供一个高性能、高可用，且具有严格顺序访问控制能力的分布式协调服务，一般以集群的方式对外提供服务，一个集群包含多个节点，每个节点对应一台ZooKeeper服务器，所有的节点共同对外提供服务，整个集群环境对分布式数据一致性提供了全面的支持，具体包括以下五大特性：

1 顺序一致性

从同一个客户端发起的请求，最终将会严格按照其发送顺序进入ZooKeeper中

2 原子性

所有请求的响应结果在整个分布式集群环境中具备原子性，即要么整个集群中所有机器都成功的处理了某个请求，要么就都没有处理，绝对不会出现集群中一部分机器处理了某一个请求，而另一部分机器却没有处理的情况

3 单一性

无论客户端连接到ZooKeeper集群中哪个服务器，每个客户端所看到的服务端模型都是一致的，不可能出现两种不同的数据状态，因为ZooKeeper集群中每台服务器之间会进行数据同步

4 可靠性

一旦服务端数据的状态发送了变化，就会立即存储起来，除非此时有另一个请求对其进行了变更，否则数据一定是可靠的

5 实时性

当某个请求被成功处理后，ZooKeeper仅仅保证在一定的时间段内，客户端最终一定能从服务端上读取到最新的数据状态，即ZooKeeper保证数据的最终一致性

二 Zookeeper实现分布式锁

public interface ZookeeperLock {
   //加锁
    public void lock();
    //解锁
    public void unlock();
}

// 实现加锁解锁
public abstract class AbstractZookeeperLock implements ZookeeperLock {
    //zk 地址和端口
    protected String zk_address="127.0.0.1:2181";
    //客户端链接
    protected ZkClient zkClient = new ZkClient(zk_address);

    protected String lockName;
    //倒计时计数器
    protected CountDownLatch countDownLatch;

    //模板方法设计模式
    @Override
    public final void lock() {
        //尝试获取锁
        if(tryLock()){
            //拿到锁
            System.out.println("获取锁成功......");
        }else{
            //未拿到锁处于等待，发生堵塞；当不阻塞了，那么继续会执行获取锁
            waitLock();
            //递归拿取锁
            lock();
        }
    }

    @Override
    public final void unlock() {
        //使用临时节点，当断开连接时 临时节点会自动删除
        if(zkClient != null){
            zkClient.close();
            System.out.println("解锁成功......");
        }
    }

    //尝试获取锁
    protected abstract boolean tryLock();

    //等待锁
    protected abstract void waitLock();
}

// 实现尝试获取锁 等待
public class ZookeeperDistributeLock extends AbstractZookeeperLock {
    public ZookeeperDistributeLock(String lockName){
        super.lockName=lockName;
    }
    @Override
    protected boolean tryLock() {
        try {
            //创建临时节点
            zkClient.createEphemeral(lockName);
            return true;
        }catch (Exception e){
            return false;
        }
    }
    @Override
    protected void waitLock() {
        //当临时节点被删除后 才能再次创建临时节点，否则处于等待状态
        IZkDataListener listener=new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {

            }
            @Override
            public void handleDataDeleted(String s) throws Exception {
                if(countDownLatch != null){
                    // -1
                    countDownLatch.countDown();
                }
            }
        };
        //1、订阅数据改变，即监听指定的节点
        zkClient.subscribeDataChanges(lockName,listener);

        //2、判断锁的节点是否存在
        if(zkClient.exists(lockName)){
            //创建锁的倒时计数器 1
            countDownLatch =new CountDownLatch(1);
            try {
                zkClient.wait();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        //3、订阅取消
        zkClient.unsubscribeDataChanges(lockName,listener);
    }
}

具体使用

	@Override
    public int addRedPacketRecord(RedPacketRecord redPacketRecord) {
        ZookeeperDistributeLock zookeeperDistributeLock=new ZookeeperDistributeLock("/addRedPacketRecord");

        try {
            zookeeperDistributeLock.lock();
            List<RedPacketRecord> redPacketRecords = redpackrecordMapper.selectRecordListByUserId(redPacketRecord.getUserId());
            if(CollUtil.isEmpty(redPacketRecords)){
                return redpackrecordMapper.addRedPacketRecord(redPacketRecord);
            }
            return 0;
        }finally {
            zookeeperDistributeLock.unlock();
        }
    }

总结