首页 > 其他分享 >深入理解ZooKeeper分布式锁

深入理解ZooKeeper分布式锁

时间:2024-01-26 23:01:52浏览次数:28  
标签:ZooKeeper String zooKeeper 节点 深入 public 分布式

第1章:引言

分布式系统,简单来说,就是由多台计算机通过网络相连,共同完成任务的系统。想象一下,咱们平时上网浏览网页、看视频,背后其实都是一大堆服务器在协同工作。这些服务器之间需要协调一致,保证数据的一致性和完整性,这就是分布式系统的挑战之一。

在这种环境下,锁就显得尤为重要了。为什么呢?因为在多个进程或者线程同时访问同一资源的时候,如果不加控制,就会造成数据混乱,比如同一时间两个线程都试图修改同一个数据,结果可能就乱套了。这就好比咱们去银行取钱,如果没有排队机制,大家都挤在一起,那取钱的过程就会变得混乱无比。

说到锁,大家可能首先想到的是传统的单机环境下的锁,比如Java里的synchronized关键字或者Lock接口。但是在分布式系统中,这些本地锁就不太管用了。因为在分布式环境下,多个进程可能在不同的机器上运行,它们无法直接通过本地锁来协调。

ZooKeeper是一个开源的分布式协调服务,它通过一种简洁的目录树结构来维护和监控存储在其上的数据,并且可以用来实现分布式锁。简单来说,ZooKeeper就像是一个分布式系统的“协调员”,帮助咱们管理和调度各种资源。

第2章:ZooKeeper概述

ZooKeeper,这个名字听起来就像是动物园的管理员,它在分布式系统中的角色也差不多。ZooKeeper是一个为分布式应用提供协调服务的软件,它的设计目标是将那些复杂的、易于出错的分布式协调工作封装起来,提供给我们一套简单易用的接口。

ZooKeeper的架构很有意思。它基于一个主从结构(Leader-Follower模式)。在这个架构中,一个Leader节点负责处理写请求,多个Follower节点则处理读请求,这样既保证了数据的一致性,又提高了系统的读性能。

咱们用ZooKeeper的时候,会跟一个叫做ZNode的东西打交道。ZNode是ZooKeeper中的数据节点,可以想象成文件系统中的文件或目录。ZooKeeper的数据模型其实就是一棵树,每个节点都可以存储数据,并且节点之间可以有父子关系。

第3章:分布式锁的基本概念

在分布式系统中,当多个进程需要共享某个资源时,如果没有适当的管理,就会出现混乱。这时候,分布式锁就派上用场了。分布式锁,顾名思义,是在分布式环境中用来控制资源访问的一种机制。它能保证在分布式系统中,同一时刻,只有一个进程能访问特定的资源。

那分布式锁和我们熟知的本地锁有什么不同呢?本地锁,像Java中的synchronizedReentrantLock,主要是用于单个进程内的多个线程之间的同步。但在分布式系统中,进程可能分布在不同的服务器上,这就需要一种机制能跨服务器工作,这就是分布式锁的用武之地。

实现分布式锁有多种方式,但原理大同小异。核心思想是在分布式系统的所有节点之间共享一个锁。这个锁可以是一个文件、一个数据库行,或者像ZooKeeper这样的系统中的一个节点。当一个进程想要访问共享资源时,它先尝试获取这个锁,成功获得锁的进程可以访问资源,其他进程则需要等待或者重试。

举个例子,假设咱们有一个购票系统,多个服务器同时在处理票务。为了避免同一张票被多次售出的情况,咱们可以使用分布式锁来保证在任何时刻,只有一个服务器能操作同一张票。

小黑现在给大家展示一个用Java实现的简单的分布式锁示例。请注意,这只是一个演示,真实环境下的分布式锁会复杂得多,并且需要考虑更多的异常情况和性能问题。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SimpleDistributedLock {
    private final Lock lock = new ReentrantLock();

    public void lock() {
        lock.lock();
        try {
            // 执行需要同步的代码
            // 例如,处理票务
        } finally {
            lock.unlock();
        }
    }
}

这个例子中,ReentrantLock是Java提供的可重入锁,但它只能用于单进程。在分布式环境中,咱们需要通过网络对这种锁进行扩展,比如使用ZooKeeper或Redis来实现锁的状态存储。

第4章:ZooKeeper分布式锁的实现原理

ZooKeeper的数据模型是一棵树,树上的每个节点称为ZNode。ZooKeeper利用这些ZNode来实现分布式锁。具体怎么做的呢?就让小黑给大家慢慢道来。

在ZooKeeper中,实现分布式锁的一个关键点是利用ZNode的特性。ZooKeeper提供了一种特殊类型的节点,叫做临时顺序节点(Ephemeral Sequential)。这种节点有两个关键特性:一是节点在创建者断开连接后会自动被删除;二是每个节点都有一个唯一的递增序号。

那怎么用这个特性来实现锁呢?咱们举个例子。假设有个共享资源,小黑想要对其加锁。小黑会在ZooKeeper的一个指定路径下创建一个临时顺序节点。这个节点的创建,就相当于是尝试获取锁。因为是顺序节点,所以每个尝试获取锁的进程都会有一个唯一且递增的序号。

获取锁的过程就是比较序号的过程。每个进程会检查自己创建的节点是否是当前路径下序号最小的节点。如果是,那么恭喜,获取锁成功,可以访问共享资源了。如果不是,就等待序号比自己小的节点释放锁。

锁的释放很简单。一旦任务完成,进程会删除自己创建的节点。一旦这个节点被删除,ZooKeeper会通知序号紧随其后的节点。

下面,小黑展示一下用Java实现ZooKeeper分布式锁的简化代码。请记住,这只是个示例,真实环境中需要考虑更多的异常处理和边界情况。

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;

public class ZooKeeperDistributedLock {
    private ZooKeeper zooKeeper;
    private String lockBasePath;
    private String lockNodePath;
    private String ourLockPath;

    public ZooKeeperDistributedLock(ZooKeeper zooKeeper, String lockBasePath, String lockNodePath) {
        this.zooKeeper = zooKeeper;
        this.lockBasePath = lockBasePath;
        this.lockNodePath = lockNodePath;
    }

    public boolean lock() throws Exception {
        // 创建临时顺序节点
        ourLockPath = zooKeeper.create(lockBasePath + "/" + lockNodePath, new byte[0], 
                                       ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                                       CreateMode.EPHEMERAL_SEQUENTIAL);

        while (true) {
            List<String> locks = zooKeeper.getChildren(lockBasePath, false);
            Collections.sort(locks);
            String smallestLock = locks.get(0);

            if (ourLockPath.endsWith(smallestLock)) {
                // 如果我们的锁是最小的,那么获得锁
                return true;
            }

            // 如果不是最小的,等待前一个锁的释放
            // 这里简化处理,实际应用中需要监听节点变化
            Thread.sleep(1000);
        }
    }

    public void unlock() throws Exception {
        // 完成任务后,删除节点,释放锁
        zooKeeper.delete(ourLockPath, -1);
    }
}

在这个代码中,lock()方法尝试获取锁,unlock()方法释放锁。咱们在尝试获取锁时,创建了一个临时顺序节点。然后检查这个节点是否是所有子节点中序号最小的。如果是,就获取了锁;如果不是,就等待。

第5章:ZooKeeper分布式锁的代码实现

咱们得有个ZooKeeper客户端的连接。这个连接是实现分布式锁的基础。下面是创建ZooKeeper客户端连接的代码:

import org.apache.zookeeper.ZooKeeper;

public class ZooKeeperConnector {
    private ZooKeeper zooKeeper;

    public ZooKeeper connect(String host) throws Exception {
        zooKeeper = new ZooKeeper(host, 3000, watchedEvent -> {
            if (watchedEvent.getState() == Watcher.Event.KeeperState.SyncConnected) {
                System.out.println("连接创建成功!");
            }
        });
        return zooKeeper;
    }

    public void close() throws Exception {
        zooKeeper.close();
    }
}

在这段代码中,ZooKeeperConnector类负责创建和关闭与ZooKeeper集群的连接。connect方法接受一个ZooKeeper服务地址,然后创建一个连接。这里用了一个简单的Watcher来确认连接是否成功建立。

连接创建好后,接下来就是实现锁的逻辑了。咱们需要实现两个主要的方法:lockunlock。这两个方法分别用于获取锁和释放锁。下面是实现这两个方法的代码:

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class DistributedLock {
    private final ZooKeeper zooKeeper;
    private final String lockRootPath = "/distributed_lock";
    private String lockNodePath;
    private String currentLockPath;

    public DistributedLock(ZooKeeper zooKeeper) {
        this.zooKeeper = zooKeeper;
    }

    public void lock() throws Exception {
        // 确保锁的根路径存在
        Stat stat = zooKeeper.exists(lockRootPath, false);
        if (stat == null) {
            zooKeeper.create(lockRootPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }

        // 创建临时顺序节点
        currentLockPath = zooKeeper.create(lockRootPath + "/lock_", new byte[0], 
                                           ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                                           CreateMode.EPHEMERAL_SEQUENTIAL);

        // 尝试获取锁
        tryLock();
    }

    private void tryLock() throws Exception {
        List<String> lockNodes = zooKeeper.getChildren(lockRootPath, false);
        Collections.sort(lockNodes);

        int index = lockNodes.indexOf(currentLockPath.substring(lockRootPath.length() + 1));
        if (index == 0) {
            // 如果是最小的节点,则表示获取锁成功
            System.out.println("锁获取成功:" + currentLockPath);
            return;
        }

        // 否则,监视前一个节点
        String prevNode = lockNodes.get(index - 1);
        CountDownLatch latch = new CountDownLatch(1);
        Stat prevStat = zooKeeper.exists(lockRootPath + "/" + prevNode, event -> {
            if (event.getType() == Watcher.Event.EventType.NodeDeleted) {
                latch.countDown();
            }
        });

        if (prevStat != null) {
            // 等待前一个节点释放
            latch.await();
            tryLock();
        } else {
            tryLock();
        }
    }

    public void unlock() throws Exception {
        // 删除节点,释放锁
        zooKeeper.delete(currentLockPath, -1);
        System.out.println("锁释放成功:" + currentLockPath);
    }
}

在这个实现中,lock方法首先确保锁的根路径存在。如果不存在,就创建一个。然后创建一个临时顺序节点。通过检查这个节点是否是最小的节点来尝试获取锁。

第6章:ZooKeeper分布式锁的高级应用

公平锁的实现

所谓公平锁,就是指等待获取锁的进程按照请求锁的顺序来获取锁。在ZooKeeper中,由于使用了临时顺序节点,实际上已经隐含了公平锁的特性。每个进程创建节点时都会被赋予一个唯一的序号,这个序号决定了它们获取锁的顺序。

读写锁的实现

读写锁是另一个常见的需求,它允许多个读操作同时进行,但写操作会独占锁。这在很多场景下都非常有用,比如允许多个用户同时读取数据,但只允许一个用户进行修改。

在ZooKeeper中实现读写锁需要更细致的控制。咱们可以创建两种类型的节点:读锁节点和写锁节点。读锁节点之间不互斥,但写锁节点会与所有其他节点互斥。下面是一个简化的读写锁实现:

public class ReadWriteLock {
    // 省略了连接ZooKeeper和基本设置的代码

    public void acquireReadLock() throws Exception {
        // 创建读锁节点
        String readLockPath = zooKeeper.create(lockRootPath + "/read_", new byte[0], 
                                               ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                                               CreateMode.EPHEMERAL_SEQUENTIAL);
        // 检查是否可以获取读锁
        checkReadLock(readLockPath);
    }

    public void acquireWriteLock() throws Exception {
        // 创建写锁节点
        String writeLockPath = zooKeeper.create(lockRootPath + "/write_", new byte[0], 
                                                ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                                                CreateMode.EPHEMERAL_SEQUENTIAL);
        // 检查是否可以获取写锁
        checkWriteLock(writeLockPath);
    }

    // 实现checkReadLock和checkWriteLock方法
    // 这里需要根据读写锁的逻辑来实现具体的检查逻辑
}

在这个代码中,acquireReadLockacquireWriteLock分别用于获取读锁和写锁。这两个方法都会创建相应类型的临时顺序节点,然后根据读写锁的规则来检查是否能够获取锁。

性能优化

在实现分布式锁时,性能也是一个非常重要的考虑点。例如,避免羊群效应(herd effect),即大量进程同时响应某个事件的情况。为了减少这种情况,可以优化锁的获取逻辑,比如使用ZooKeeper的Watcher机制来有效地通知等待的进程,而不是让所有进程都去轮询检查锁的状态。

第7章:ZooKeeper分布式锁的局限性和替代方案

虽然ZooKeeper分布式锁在很多场景下都非常有用,但小黑得实话实说,它并不是银弹,也有它的局限性。理解这些局限性,可以帮助咱们更好地选择和设计分布式锁方案。

ZooKeeper分布式锁的局限性

  1. 性能问题:ZooKeeper的节点创建和删除操作涉及到网络通信和磁盘I/O,这可能会成为性能瓶颈。特别是在锁的竞争非常激烈的情况下,性能问题会更加明显。

  2. 集群依赖:ZooKeeper自身是一个集群系统,它的可用性和稳定性直接影响到分布式锁的可靠性。如果ZooKeeper集群出现问题,那么基于它的分布式锁也会受到影响。

  3. 复杂性:ZooKeeper的使用和维护比较复杂,需要有一定的学习曲线。对于一些小团队来说,可能没有足够的资源去维护一个ZooKeeper集群。

替代方案

鉴于ZooKeeper分布式锁的这些局限性,咱们可以考虑一些其他的替代方案:

  1. 基于数据库的锁:使用数据库的行锁或表锁来实现分布式锁。这种方法简单直接,但可能会受限于数据库的性能和可扩展性。

  2. Redis分布式锁:Redis是一种高性能的键值存储系统,它也可以用来实现分布式锁。Redis分布式锁的实现通常基于SET命令的NX(Not eXists)和EX(Expire)选项,性能较好,但需要处理好锁的续租问题。

  3. Etcd分布式锁:Etcd是一个高可用的键值存储系统,专为分布式系统的配置管理和服务发现而设计。Etcd的分布式锁基于租约机制,提供了比ZooKeeper更为简洁的API。

咱们来看一个使用Redis实现分布式锁的简单例子:

import redis.clients.jedis.Jedis;

public class RedisDistributedLock {
    private Jedis jedis;
    private String lockKey;
    private String lockValue;

    public RedisDistributedLock(Jedis jedis, String lockKey, String lockValue) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.lockValue = lockValue;
    }

    public boolean tryLock(long timeout) {
        long endTime = System.currentTimeMillis() + timeout;
        while (System.currentTimeMillis() < endTime) {
            if (jedis.setnx(lockKey, lockValue) == 1) {
                jedis.expire(lockKey, 30); // 设置锁的过期时间
                return true;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return false;
    }

    public void unlock() {
        if (lockValue.equals(jedis.get(lockKey))) {
            jedis.del(lockKey);
        }
    }
}

在这个例子中,tryLock方法尝试设置一个键值对,如果设置成功(即之前没有这个锁),则获取锁成功;unlock方法则检查并删除这个键值对来释放锁。这只是一个基础版本,实际使用时还需要加入更多的错误处理和优化。

第8章:总结

现代应用越来越多地采用分布式架构。无论是大型的互联网服务还是微服务架构,分布式系统已经成为了主流。在这种环境下,对资源的并发访问和协调变得非常重要。ZooKeeper分布式锁正是为解决这种并发问题而生。

ZooKeeper分布式锁不仅是一个技术问题,它还体现了对分布式系统理解的深度和广度。

标签:ZooKeeper,String,zooKeeper,节点,深入,public,分布式
From: https://blog.51cto.com/u_16326109/9439135

相关文章

  • 分布式文件系统
    1、分布式文件系统是由多态主机模拟出来的一个文件系统,文件是分散存储在不同的主机上2、分布式文件系统有很多种:1)、GFSGFS(GoogleFileSystem)是Google公司为满足公司需求而开发的基于Linux的可扩展的分布式文件系统,用于大型的、分布式的、对大数据进行访问和应用,成本低,应用于廉价......
  • 京东广告算法架构体系建设--在线模型系统分布式异构计算演变 | 京东零售广告技术团队
    一、现状介绍 算法策略在广告行业中起着重要的作用,它可以帮助广告主和广告平台更好地理解用户行为和兴趣,从而优化广告投放策略,提高广告点击率和转化率。模型系统作为承载算法策略的载体,目前承载搜索、推荐、首焦、站外等众多广告业务和全链路的深度学习建模,是广告算法算法创新......
  • 基于 ELK 分布式日志系统搭建
    0、前景采用ELK搭建一套分布式日志系统架构图1、ElastsiSearch官网地址Elasticsearch8.12.0|Elastic1.1、安装下载安装包wgethttps://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.12.0-linux-x86_64.tar.gztar-zxvfelasticsearch-8.12.0-......
  • SpringBoot中集成XXL-JOB分布式任务调度平台,轻量级、低侵入实现定时任务
    场景XXL-JOBhttps://www.xuxueli.com/xxl-jobXXL-JOB是一个分布式任务调度平台,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。特性:1、简单:支持通过Web页面对任务进行CRUD操作,操作简单,一分钟上手;2、动态:支持动态修改任务状态、启动/停止任务,以及终止运行中任务,即时生......
  • 【译】解开托管内存的秘密:深入了解事件处理程序泄漏!
    事件处理程序泄漏已经存在很长时间了,这是WPF(WindowsPresentationFoundation)开发人员经常要处理的最麻烦的问题之一。您可能会想:是什么让事件处理程序泄漏如此重要?事件处理程序泄漏很容易引起,只需忘记取消订阅事件即可。此外,它们很难发现,甚至更难修复。在更新17.9预......
  • Kafka 与 Zookeeper 关系
    Zookeeper为Kafka提供集群的管理。不仅保存着集群的Broker、Topic、Partition等元数据,还负责Broker故障发现、Leader选举、负载均衡等。Broker元数据管理在Zookeeper上会有一个专门用来进行Broker服务器列表记录的节点。每个Broker在启动时,都会到Zookeeper上......
  • 深入解析C++中sizeof和strlen的奥秘:区别、应用与技巧全揭秘!
     sizeof 和 strlen 是C++中用于处理字符串的两个不同的操作符,它们的作用和使用场景有很大的区别。sizeof操作符:区别:sizeof 是一个运算符,不是一个函数,用于获取一个类型或变量的字节大小。对于数组,sizeof 返回整个数组的字节大小。对于指针,sizeof 返回指针本身的......
  • 支撑核心系统分布式改造,GaussDB为江南农商银行筑稳根基
    本文分享自华为云社区《支撑核心系统分布式改造,GaussDB为江南农商银行筑稳根基》,作者:华为云头条。在移动互联网快速普及的当下,金融机构能否提供便捷、智能、个性化的金融服务,成为关乎业务开展和企业成长的重要命题。高性能、高可用、高安全的数据库,则是金融服务背后的重要支撑。......
  • nfs服务的工作原理深入浅出讲解_
    1.NFS挂载原理详细介绍 2.什么是RPC服务 NFS的执行流程工作原理:  ......
  • [转帖]深入JVM - Code Cache内存池
    深入JVM-CodeCache内存池1.本文内容本文简要介绍JVM的CodeCache(本地代码缓存池)。2.CodeCache简要介绍简单来说,JVM会将字节码编译为本地机器码,并使用CodeCache来保存。每一个可执行的本地代码块,称为一个nmethod。nmethod可能对应一个完整的Java方法,或......