Zookeeper实现分布式锁

在之前的文章中,我们介绍了使用Redis实现分布式锁,这篇文章中,我们通过模拟一个实例来看一下分布式锁的另外一种实现方式,使用Zookeeper(后面简称zk)实现分布式锁。

使用zk实现分布式锁,主要依赖于它的两个特性:

Zookeeper实现分布式锁

zk节点根据是否持久、是否有序分为4类:

持久节点:客户端与zk断开后,节点不会自动删除,需要手动删除

持久顺序节点:在持久节点的基础上,对节点名称进行了顺序编号

临时节点:客户端与zk断开连接后,节点会自动删除

临时顺序节点:在临时节点的基础上,对节点名称进行了顺序编号

Zookeeper实现分布式锁

客户端注册监听它关心的节点,当节点上发生事件变化时,zk会通知客户端。主要事件包括:

NodeCreated:节点被创建时,该事件被触发

NodeChildrenChanged:子节点被创建、被删除、子节点数据发生变更时,该事件被触发

NodeDataChanged:节点的数据发生变更时,该事件被触发

NodeDeleted:节点被删除时,该事件被触发

None:当zk客户端的连接状态发生变更时,该事件被触发

Zookeeper实现分布式锁

介绍完这两点特性,我们再看一下使用zk实现分布式锁要注意的几点:

实现目的:在多线程竞争锁时,只能有一个线程能够获得分布式锁

实现思路:使用顺序节点实现,只有兄弟节点中序号值为最小值的节点能够获得分布式锁

释放锁:释放锁通过删除节点实现,为了避免节点线程宕机而没有释放分布式锁的情况,可以使用临时节点自动释放分布式锁

监听:每个节点监听它的前一个顺序节点的删除事件,当监听到删除事件后,判断自己是不是最小序号的节点,如果是则获得分布式锁

Zookeeper实现分布式锁

我们以电商平台一次购买流程为例,在进行一次下单的过程中,首先需要创建订单、然后查询库存,最终完成支付操作。三个过程有明显的先后流程关系,并且减库存必须要保证原子操作。

创建订单:    

public class Order {
    public void createOrder(){
        System.out.println(Thread.currentThread().getName()+"创建订单");
    }
}

减少库存,这里设置库存数量为1。如果只有一个线程能够执行减库存成功,那么证明分布式锁实现成功:


public class Stock {
    private static Integer COUNT=1;
    public boolean reduceStock() {
        if (COUNT>0){
            COUNT--;
            return true;
        }
        return false;
    }
}

用户支付:


public class Pay {
    public void pay(){
        System.out.println(Thread.currentThread().getName()+"支付成功");
    }
}

使用zk实现分布式锁:

实现Lock接口,重写lock()方法,tryLock()方法,unLock()核心方法,作为分布式锁的加锁、解锁方法

使用apache.ZooKeeper原生客户端api操作Zookeeper

在zk的"/LOCK"节点下创建"zk_"开头的临时顺序节点,通过节点序号大小判断自己能否获得锁

使用ThreadLocal存储节点的名称,保证线程安全。其中存储了节点自己的名字,作为判断自己是否最小节点的依据

如果没有获取到锁,则使用Watcher监控自己的前一个节点。因为Watcher是异步操作,使用CountDownLatch进行阻塞,当前一个节点被删除时才被唤醒

具体实现:

public class ZkLock implements Lock {
    private ThreadLocal<ZooKeeper> zk=new ThreadLocal<>();
    private String LOCK_NAME="/LOCK";
    private ThreadLocal<String> CURRENT_NODE=new ThreadLocal<>();

    public void init(){
        if (zk.get()==null){
            try {
                zk.set(new ZooKeeper("localhost:2181", 300, new Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        System.out.println("watch event");
                    }
                }));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void lock(){
        init();
        if(tryLock()){
            System.out.println(Thread.currentThread().getName()+"已经获取到锁了");
        }
    }

    public boolean tryLock(){
        String nodeName=LOCK_NAME+"/zk_";
        try {
            CURRENT_NODE.set( zk.get().create(nodeName, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL));
            List<String> list = zk.get().getChildren(LOCK_NAME, false);
            Collections.sort(list);
            String minNodeName = list.get(0);

            if (CURRENT_NODE.get().equals(LOCK_NAME+"/"+minNodeName)){
                return true;
            }else{
                //监听前一个节点
                String currentNodeSimpleName=CURRENT_NODE.get().substring(CURRENT_NODE.get().lastIndexOf("/") + 1);
                int  currentNodeIndex= list.indexOf(currentNodeSimpleName);
                String preNodeSimpleName = list.get(currentNodeIndex - 1);
                System.out.println(Thread.currentThread().getName()+"-监听节点:"+preNodeSimpleName);
        
                CountDownLatch countDownLatch=new CountDownLatch(1);
                zk.get().exists(LOCK_NAME + "/" + preNodeSimpleName, new Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        if (Event.EventType.NodeDeleted.equals(event.getType())){
                            countDownLatch.countDown();
                            System.out.println(Thread.currentThread().getName()+"被唤醒");
                        }
                    }
                });
                System.out.println(Thread.currentThread().getName()+"阻塞住");
                countDownLatch.await();
                return true;
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    public void unlock(){
        try {
            //-1表示忽略版本号,强制删除
            zk.get().delete(CURRENT_NODE.get(),-1);
            System.out.println(Thread.currentThread().getName()+"-删除节点");
            CURRENT_NODE.set(null);
            zk.get().close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {
    }
    @Override
    public Condition newCondition() {
        return null;
    }
}

主程序,使用两个线程竞争分布式锁:

public class Main {
    public static void main(String[] args) {
        Thread user1 = new Thread(new UserThread(), "user1");
        Thread user2 = new Thread(new UserThread(), "user2");
        user1.start();
        user2.start();
    }
    static Lock lock=new ZkLock();
    static class UserThread implements Runnable{
        @Override
        public void run() {
            new  Order().createOrder();
            lock.lock();
            boolean result = new Stock().reduceStock();
            lock.unlock();
            if (result){
                System.out.println(Thread.currentThread().getName()+"减库存成功");
                new Pay().pay();
            }else {
                System.out.println(Thread.currentThread().getName()+"减库存失败");
            }
        }
    }
}

查看运行结果:

Zookeeper实现分布式锁

可以看到,在两个用户完成创建订单操作后,只有一个线程能够减少库存成功。实际执行中,user2获取到分布式锁并减库存成功,而user1被阻塞,无法完成后续操作。

上一篇:微服务架构中使用 ELK 进行日志采集以及统一处理--《我和开源的故事》


下一篇:Java动态代理的介绍与实践——《我的Java打怪日记》