zookeeper入门篇

已于 2023-06-02 11:22:14 修改
阅读量774 收藏 1
点赞数 1
分类专栏： 分布式 文章标签： java-zookeeper zookeeper java
于 2022-12-27 21:36:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28911061/article/details/128461743
版权

文章目录

前言

本篇旨在了解zookeeper和使用它，因为我也是刚开始接触，所以没有过度深入。
为什么学习它，zookeeper作为分布式协调系统，应用于springCloud ，dubbo，kafka，Hadoop等，算是比较主色的一个系统。

介绍

首页zookeeper是分布式协调框架，主要用来解决分布式应用中经常遇到的数据管理问题，如：统一命名服务、状态同步、集群管理、分布式应用配置项的管理等。

安装与启动

  1. 下载：https://dlcdn.apache.org/zookeeper/zookeeper-3.6.3/apache-zookeeper-3.6.3-bin.tar.gz

  2. 解压：tar -xf

  3. bin目录设置成环境变量

vi ~/.bash_profile 

export ZOOKEEPER_HOME=/data/zk/apache-zookeeper-3.6.3-bin
export PATH=$PATH:$ZOOKEEPER_HOME/bin

  1. 复制zoo_sample.cfg -> zoo.cfg；zoo.cfg才是启动配置

    cp zoo_sample.cfg zoo.cfg

  2. 启动zookeeper服务端，出现【started】就是启动成功了

    ./bin/zkServer.sh start

  3. 启动zookeeper客户端，没有报错就是连上了

    ./bin/zkCli.sh

配置说明

zoo.cfg

    # 心跳时间间隔，单位毫秒
tickTime=2000
    # 数据同步最长时间 10*2=20秒
initLimit=10
    # 心跳检查时的存活时间，超过这个时间，判断为不存活
syncLimit=5
    # 持久化配置
dataDir=/tmp/zookeeper
    # 客户端端口
clientPort=2181
# 客户端连接最大数量
#maxClientCnxns=60
# 持久化目录保存的快照数
#autopurge.snapRetainCount=3
# 清除多余日志和快照的时间间隔，=0时禁用
#autopurge.purgeInterval=1

## Metrics Providers
#
# https://prometheus.io Metrics Exporter
#metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider
#metricsProvider.httpPort=7000
#metricsProvider.exportJvmInfo=true

节点

它维护着一个类似文件系统的数据结构，每一个子目录项被称为znode(目录节点)

节点类型

PERSISTENT（持久化节点）

客户端与zookeeper断开连接后，该节点依旧存在，只要不手动删除该节点，他将永远存在

PERSISTENT_SEQUENTIAL（持久化顺序节点）

客户端与zookeeper断开连接后，该节点依旧存在，只是zookeeper给该节点名称进行顺序编号

EPHEMERAL（临时节点）

客户端与zookeeper断开连接后，该节点被删除。

  1. 临时节点下不能拥有子节点
  2. 其他客户端也能看到临时节点

EPHEMERAL_SEQUENTIAL（临时顺序节点）

客户端与zookeeper断开连接后，该节点被删除，只是zookeeper给该节点名称进行顺序编号

Container（容器节点）

3.5.3 版本新增，如果Container节点下面没有子节点，则Container节点在未来会被zookeeper自动清除,定时任务默认60s 检查一次

PERSISTENT_WITH_TTL（持久化TTL节点）

3.5.3 版本新增，默认禁用，只能通过系统配置 zookeeper.extendedTypesEnabled=true 开启，拥有一个过期时间

PERSISTENT_SEQUENTIAL_WITH_TTL（持久化TTL顺序节点）

3.5.3 版本新增，默认禁用，只能通过系统配置 zookeeper.extendedTypesEnabled=true 开启，在顺序节点的基础上增加了过期时间概念

基本操作

连接后，可以进行创建节点、修改、删除节点和数据，详细的命令它都有提示（随便输入一个就会打印提示）

zookeeper的数据结构是类似文件系统的数据结构，所以，它的节点可以看做是一个目录，比如/test，作为一个节点，需要一个/作为路径前缀，也表示他是根节点下名字叫test的节点，同理，子节点也是一样，如/test/t，表示根节点下名为test的节点下有一个节点t。

创建节点

#创建名为test的znode节点

create /test

#查看节点列表

ls /

设置数据

#设置了节点为test的数据为xxx

set /test xxx

获取节点数据

#获取节点为test的数据

get /test

#获取节点详细信息

get -s /test

列出节点

ls /

状态

stat /test

删除

delete /test

#删除所有的节点，保护子节点

deleteall /test

监听

这种方式的监听是一次性的，只能监听一次。

#开启一个新的客户端

get -w /test

#通过另一个客户端修改/test数据

set /test sdsds

image-20221222210801482

权限（ACL）

  • zookeeper的权限是基于节点的， 所以需要对每个节点做权限
  • 每个znode支持设置多种权限控制方案和多个权限
  • 子节点不会接触父节点的权限

zookeeper的权限构成：scheme🆔permissions

  1. scheme: 代表权限机制，包括world、auth、digest、ip、super几种
  2. id： 代表允许访问的用户
  3. permissions：权限组合字符串，有cdrwa组成；create（c），delete（d），read（r），write（w），admin（a）

之前创建的节点，都是下面的权限，也是默认的权限。

'world,'anyone
cdrwa

设置world权限

#创建一个子节点

create /test/t

#查看权限

getAcl /test/t

#设置权限只为创建读取

setAcl /test/t world:anyone:cr

尝试写入数据

set /test/t sssss

image-20221222111539769

设置auth权限

首先创建用户

addauth digest ali:123456

然后创建一个指定用户，且只有读写的权限的节点

create /test/tt xxx auth:ali:123456:cwr

然后再开一个客户端来验证

image-20221222112227828

设置digest权限

这个需要密码加密，所以使用下面的命令加密

#使用sha1算法加密后，再用base64加密

echo -n ali:123456 | openssl dgst -binary -sha1 | openssl base64

image-20221222112505793

得到加密密码后，进行权限设置，统一只有读写权限

create /test/ttt xsxs digest:ali:sEcavS+dPUZVZKgy6MHOOj/AKTs=:cwr

再使用另一个客户端查看

image-20221222112743676

登录再操作，发现已经可以操作了。

addauth digest ali:123456

image-20221223112454630

设置ip权限

限制操作的ip

create /test/t2 tt2x ip:192.168.0.110:cwr

通过另一台服务器尝试连接

./bin/zkCli.sh -server 192.168.0.110:2181

可是，在通过其他服务器连接时，出现下面报错：

image-20221222125410273

经过排查，是因为我zookeeper所在的服务器，没有把端口2181开放

firewall-cmd --add-port=2181/tcp --permanent

image-20221222222807152

设置super权限

admin权限拥有所有的权限，在出现没有权限操作的节点时，可以通过admin权限进行操作。

先生成秘钥

echo -n super:admin | openssl dgst -binary -sha1 | openssl base64

在zkServer.sh脚本正添加启动参数，如下（秘钥前面添加账号名）：

-Dzookeeper.DigestAuthenticationProvider.superDigest=super:xQJmxLMiHGwaqBvst5y6rkB6HQs=

image-20221223110800737

创建一个只有读权限的节点

image-20221223111412255

通过另一个客户端，登录super

addauth digest super:admin

image-20221223112138378

image-20221223112126498

可以看到，即使没有写权限，admin登录的仍然可以修改。

注意点：设置了删除权限，但是还是可以用delete命令操作，感觉权限是针对deleteall的，并不适用delete命令

原生客户端

zookeeper有两个客户端；其一便是上面我们使用的zkCli.sh，其二就是Java客户端。

    private static final String CONNECT_STR = "192.168.0.110:2181";

    private static final int TIME_OUT = 30000;

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {

        final CountDownLatch latch = new CountDownLatch(1);
        Watcher startWatcher = new Watcher() {
            public void process(WatchedEvent watchedEvent) {
                if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                    System.out.println("建立连接");
                    latch.countDown();
                }
                String path = watchedEvent.getPath();
                System.out.println("path:" + path);
            }
        };

        ZooKeeper zookeeper = new ZooKeeper(CONNECT_STR, TIME_OUT, startWatcher);
        // zookeeper内部有开启子线程，所以这里通过countlatch锁阻止主线程的执行
        latch.await();

        // 判断节点/test是否存在
        Stat exists = zookeeper.exists("/test", false);
        // 当节点不存在时exits=null
        System.out.println(exists);


        // 获取节点/test数据
        // 查询节点，需要一个stat来承载节点信息
        Stat stat = new Stat();
        byte[] data = zookeeper.getData("/test", false, stat);
        System.out.println("节点/test数据：");
        System.out.println(new String(data));


        // 修改节点/test数据
        // version=-1表示不检查版本，乐观锁的实现，可以通过stat拿到version(stat.getVersion())
        zookeeper.setData("/test", "false".getBytes(), -1);
        data = zookeeper.getData("/test", false, stat);
        System.out.println("节点/test修改后的数据：");
        System.out.println(new String(data));

        // 创建节点/test/ttttt
        ZkData d = new ZkData();
        d.setKey("ddd");
        d.setValue("vvv");

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.writeValueAsBytes(d);

        String s = zookeeper.create("/test/tttt", objectMapper.writeValueAsBytes(d), ZooDefs.Ids
                                        .OPEN_ACL_UNSAFE,
                                    CreateMode.PERSISTENT);


        data = zookeeper.getData("/test/tttt", false, stat);
        System.out.println("节点/test/tttt的数据：");
        System.out.println(new String(data));

    }

image-20221222223714466

监听场景

 Watcher dataWatch = new Watcher() {
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeDataChanged) {
                    System.out.println("数据更新");
                    System.out.println(event);
                    // 重新获取一次数据getData
                    try {
                        byte[] data1 = zookeeper.getData("/test", false, null);
                        System.out.println(new String(data1));
                    } catch (KeeperException | InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
byte[] data1 = zookeeper.getData("/test", dataWatch, null);
System.out.println();
// 这里阻止zookeeper监听线程结束
TimeUnit.SECONDS.sleep(600);

在命令行客户端修改/test节点数据，java客户端这边收到change事件

image-20221223112802847

curator

private static final String CONNECT_STR = "192.168.0.110:2181";

private static final int TIME_OUT = 30000;

public static void main(String[] args) throws Exception {

    // 重试配置
    RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
    CuratorFramework client = CuratorFrameworkFactory.builder()
                                                     .connectString(CONNECT_STR)
                                                     .sessionTimeoutMs(TIME_OUT)
                                                     .connectionTimeoutMs(TIME_OUT)
                                                     .retryPolicy(retryPolicy)
                                                     .build();
    client.start();

    // 创建节点
    String path = client.create().forPath("/test2", "xxx".getBytes());
    System.out.println(path);

    // 查询节点数据
    byte[] bytes = client.getData().forPath("/test2");
    System.out.println("获取到的数据：" + new String(bytes));

    // 修改节点数据
    Stat stat = client.setData().forPath("/test2", "777".getBytes());
    bytes = client.getData().forPath("/test2");
    System.out.println("修改后的数据：" + new String(bytes));

    // 删除节点
    client.delete().forPath("/test2");
    // 节点不存在，这里报异常
    bytes = client.getData().forPath("/test2");
    System.out.println("删除后的数据：" + new String(bytes));
}

image-20221223144924501

NodeCache

监听当前节点数据的变化

    private static final String CONNECT_STR = "192.168.0.110:2181";

    private static final int TIME_OUT = 30000;

    public static void main(String[] args) throws Exception {

        // 重试配置
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.builder()
                                                         .connectString(CONNECT_STR)
                                                         .sessionTimeoutMs(TIME_OUT)
                                                         .connectionTimeoutMs(TIME_OUT)
                                                         .retryPolicy(retryPolicy)
                                                         .build();
        client.start();
        NodeCache nodeCache = new NodeCache(client, "/test2");
        nodeCache.start();
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
  System.out.println("数据变更");
                ChildData currentData = nodeCache.getCurrentData();
                System.out.println(new String(currentData.getData()));
            }
        });
        
        TimeUnit.SECONDS.sleep(6000);

    }

每次在变更后，都会被监听到

image-20221223163519237

PathChildrenCache

监听子节点

PathChildrenCache pathChildrenCache = new PathChildrenCache(client, "/test2", true);
pathChildrenCache.start();
pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
    @Override
    public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent)
    throws Exception {
        switch (pathChildrenCacheEvent.getType()) {
            case CHILD_ADDED:
                System.out.println("新增子节点");
                System.out.println("新增节点的数据：" + new String(pathChildrenCacheEvent.getData().getData()));
                break;
            case CHILD_UPDATED:
                System.out.println("更新子节点");
                System.out.println("更新节点的数据：" + new String(pathChildrenCacheEvent.getData().getData()));
                break;
            default:break;
        }
    }
});

TimeUnit.SECONDS.sleep(6000);

image-20221223164806379

TreeCache

监听当前节点和子节点

TreeCache treeCache = new TreeCache(client, "/test2");
treeCache.start();

treeCache.getListenable().addListener(new TreeCacheListener() {
    @Override
    public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
        switch (treeCacheEvent.getType()) {
            case NODE_UPDATED:
                System.out.println("更新节点");
                System.out.println("更新节点的数据：" + new String(treeCacheEvent.getData().getData()));
                break;
            default:break;
        }
    }
});

TimeUnit.SECONDS.sleep(6000);

集群

我这里单机搭建集群，有些步骤也差不多的。

  1. 准备目录

    mkdir /data/zk/data
mkdir /data/zk/data2
mkdir /data/zk/data3
mkdir /data/zk/logs
mkdir /data/zk/logs2
mkdir /data/zk/logs3

  2. 修改zoo.cfg，因为我单机，所以需要改动端口，和目录等

    # 心跳时间间隔，单位毫秒
tickTime=2000
    # 数据同步最长时间 10*2=20秒
initLimit=10
    # 心跳检查时的存活时间，超过这个时间，判断为不存活
syncLimit=5
    # 持久化配置
dataDir=/data/zk/data
dataLogDir=/data/zk/logs
    # 客户端端口
clientPort=2181

# 集群配置
# server.x 这个x代表data/myid里的值，localhost是zookeeper服务坐在的ip地址，第一个端口是通信端口，第二个端口是选举端口
server.1=localhost:2887:3887
server.2=localhost:2888:3888
server.3=localhost:2889:3889

复制配置zoo2.cfg

    # 心跳时间间隔，单位毫秒
tickTime=2000
    # 数据同步最长时间 10*2=20秒
initLimit=10
    # 心跳检查时的存活时间，超过这个时间，判断为不存活
syncLimit=5
    # 持久化配置
dataDir=/data/zk/data2
dataLogDir=/data/zk/logs2
    # 客户端端口
clientPort=2182

# 集群配置
# server.x 这个x代表data/myid里的值，localhost是zookeeper服务坐在的ip地址，第一个端口是通信端口，第二个端口是选举端口
server.1=localhost:2887:3887
server.2=localhost:2888:3888
server.3=localhost:2889:3889

zoo3.cfg

    # 心跳时间间隔，单位毫秒
tickTime=2000
    # 数据同步最长时间 10*2=20秒
initLimit=10
    # 心跳检查时的存活时间，超过这个时间，判断为不存活
syncLimit=5
    # 持久化配置
dataDir=/data/zk/data3
dataLogDir=/data/zk/logs3
    # 客户端端口
clientPort=2183

# 集群配置
# server.x 这个x代表data/myid里的值，localhost是zookeeper服务坐在的ip地址，第一个端口是通信端口，第二个端口是选举端口
server.1=localhost:2887:3887
server.2=localhost:2888:3888
server.3=localhost:2889:3889

  1. 创建myid

    # 在每个data下创建myid文件，值分别是1,2,3，对应zoo.cfg配置文件最后的server.x后缀
vi /data/zk/data/myid
vi /data/zk/data2/myid
vi /data/zk/data3/myid

  2. 启动

    启动器，需要全部的zookeeper服务都是关闭的。

    ./bin/zkServer.sh start conf/zoo.cfg
./bin/zkServer.sh start conf/zoo2.cfg
./bin/zkServer.sh start conf/zoo3.cfg

  3. 查看服务状态

    ./bin/zkServer.sh status conf/zoo.cfg
./bin/zkServer.sh status conf/zoo2.cfg
./bin/zkServer.sh status conf/zoo3.cfg

    image-20221223174208113

  4. 操作测试

    连接3个客户端，尝试，创建一个节点，活修改一个节点数据，可以发现已经同步了。

    image-20221223174411935image-20221223174422501image-20221223174432934

分布式锁

代码仓库：https://gitee.com/LIRUIYI/test-zk.git

非公平锁

通过创建节点，并判断节点是否存在实现分布式锁。

  1. 创建临时节点，如/lock，临时节点是当出现异常，没有删除导致永久加锁的情况发生
  2. 当节点不存在，创建节点成功，也就意味着枷锁成功，如果创建失败，那么就是加锁失败
  3. 其他需要加锁的线程，监听/lock节点（get -w /lock），当节点/lock删除后，zookeeper会通知到监听的节点

这种方式的加锁，不能保证需要加锁的线程能得到锁的概率一样，他们是随机的，有可能最先排队的加锁线程，到最后都不能得到锁，这就是非公平锁。

以原始客户端实现非公平锁：

这里zookeeper地址和上面不一样，因为之前是桥接模式，自动获取的，有时ip会变动，所以改NAT模式，设定了静态ip

package com.liry.zk;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import lombok.extern.slf4j.Slf4j;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;

/**
 * 分布式锁 - 非公平锁实现
 *
 * @author ALI
 * @since 2022/12/25
 */
@Slf4j
public class NonfairSyncLock {

    private static final String CONNECT_STR = "192.168.17.128:2181";

    private static final int TIME_OUT = 30000;

    private static final String LOCK_PATH = "/lock";

    private static ZooKeeper zookeeper = null;

    /**
     * 获取客户端
     */
    public static ZooKeeper getClient() throws IOException, InterruptedException {
        synchronized (LOCK_PATH) {
            final CountDownLatch latch = new CountDownLatch(1);
            if (zookeeper == null) {
                Watcher startWatcher = watchedEvent -> {
                    if (watchedEvent.getState() == Watcher.Event.KeeperState.SyncConnected) {
                        log.info("与zookeeper建立连接");
                        latch.countDown();
                    }
                };
                zookeeper = new ZooKeeper(CONNECT_STR, TIME_OUT, startWatcher);
                latch.await();
            } else if (zookeeper.getState() != ZooKeeper.States.CONNECTED) {
                latch.await();
            }
        }
        return zookeeper;
    }

    /**
     * 加锁
     */
    public void lock() {
        while (true) {
            if (tryLock()) {
                return;
            }
            // 加锁失败，增加监听，然后阻塞
            try {
                watch();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
     * 解锁
     */
    public void unlock() {
        try {
            getClient().delete(LOCK_PATH, -1);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 尝试加锁
     */
    private boolean tryLock() {
        try {
            getClient().create(LOCK_PATH, "lock".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                               CreateMode.EPHEMERAL);
        } catch (Exception e) {
            log.error("加锁失败");
            return false;
        }
        return true;
    }

    /**
     * 监听锁节点
     * 当节点存在时，线程阻塞，当节点不存在，直接退出监听
     */
    private void watch() throws InterruptedException, KeeperException, IOException {
        CountDownLatch latch = new CountDownLatch(1);
        Watcher dataWatch = event -> {
            if (event.getType() == Watcher.Event.EventType.NodeDeleted) {
                latch.countDown();
            }
        };
        try {
            getClient().getData(LOCK_PATH, dataWatch, null);
        } catch (KeeperException.NoNodeException e) {
            // 当创建监听时，节点不存在，说明有线程解锁了，那么直接退出，监听步骤，去争抢锁
            return;
        }
        latch.await();
    }

}


    static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        nonFairLock();
    }

    private static void nonFairLock() throws InterruptedException {
        NonfairSyncLock lock = new NonfairSyncLock();

        CountDownLatch latch = new CountDownLatch(1000);
        List<Thread> threadList = IntStream.range(0, 1000).mapToObj(d -> new Thread(() -> {
            lock.lock();
            count += 1;
            latch.countDown();
            lock.unlock();
        }, "线程-" + d)).collect(Collectors.toList());

        threadList.forEach(Thread::start);

        latch.await();
        System.out.println("最终结果应是1000：" + count);
    }

公平锁

相对于非公平锁的实现，这个方式较为复杂一点。

  1. 先创建一个根节点/lock

  2. 再在/lock下创建临时有序节点，有序节点是因为所有需要加锁的节点需要按先来后到的顺序才能公平

  3. 然后每个有序节点都监听它的前一个节点，如图，当前一个节点被删除，表示解锁了，那么zookeeper会通知到监听的节点，也就是下一个需要加锁的线程

    image-20221225132210169

这个在curator中已经有实现了，分布式锁不局限于zookeeper，了解其原理就行

static int count = 0;

    public static void main(String[] args) throws InterruptedException {
//        nonFairLock();
        fairLock();
    }

    private static void fairLock() throws InterruptedException {
        // 使用curator客户端
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.builder()
                                                         .connectString("92.168.17.128:2181")
                                                         .sessionTimeoutMs(3000)
                                                         .connectionTimeoutMs(3000)
                                                         .retryPolicy(retryPolicy)
                                                         .build();
        client.start();
        
        InterProcessMutex lock = new InterProcessMutex(client, "/lock");

        CountDownLatch latch = new CountDownLatch(1000);
        List<Thread> threadList = IntStream.range(0, 1000).mapToObj(d -> new Thread(() -> {
            try {
                lock.acquire();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            count += 1;
            latch.countDown();
            try {
                lock.release();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }, "线程-" + d)).collect(Collectors.toList());

        threadList.forEach(Thread::start);

        latch.await();
        System.out.println("最终结果应是1000：" + count);
    }
用针戳左手中指指头
关注
专栏目录
Zookeeper入门篇
m0_49853352的博客
12-21 1391
第一部分 初识zookeeper？ 1，什么是zookeeper？ 1，高可用、高性能、开源的分布式协调服务。为分布式应用提供一致性服务，可以实现发布/订阅，负载均衡，分布式协调/通知，集群管理等 2，目标是封装好复杂易出错的关键服务，提供给用户 3，ZooKeeper保证了分布式一致性（顺序一致性、原子性、单一视图、可靠性、实时性/最终一致性） 4，客户端的读请求 5，有序性，所有更新都是全局有序的 2，zookeeper的linux环境搭建 官网下载地址Apache ZooKeeper 步骤： 因为
ZooKeeper入门，看这篇就够了！
yehongzhi1994的博客
07-12 756
为什么使用ZooKeeper？如何使用ZooKeeper，看这篇就够了
zookeeper-3.6.3安装文档（单机或集群）
SuperlcBlog
09-29 853
apache-zookeeper-3.6.3-bin.tar.gz zookeeper镜像地址:https://dlcdn.apache.org/zookeeper/zookeeper-3.6.3/ zookeeper官网:https://zookeeper.apache.org/ zookeeper下载:https://zookeeper.apache.org/releases.html zookeeper3.6.3文档：http://zookeeper.apache.org/doc/r3.6.3/ind
Zookeeper学习笔记（二）——Zookeeper的java客户端搭建
飞！！！的博客
04-11 3256
java实现zookeeper客户端
zookeeper znode有哪些类型
皇天霸的博客
06-15 3992
znode类型我们常见的有四种，分别是： PERSISTENT：永久节点，从一开始被创建永久存在直到被主动删除，不会因为client的session断开而被删除。 PERSISTENT_SEQUENTIAL：永久有序节点，跟PERSISTENT一样，唯一的区别是节点名会被追加一个单调递增的十进制序号。 EPHEMERAL：临时节点，被client创建，client断开连接，节点就被删除。 EPHEMERAL_SEQUENTIAL：临时有序节点，被client创建，client断开连接，节点就被删除，
Zookeeper内部原理
qq_61645895的博客
01-18 235
Zookeeper内部原理,Stat结构体,监听器原理,Paxos算法（扩展）等
Zookeeper基础学习
Sun_of_Rainy的博客
11-20 1467
1、安装zookeeper以及以及ZooInspector 注：zookeeper打开为什么会一闪而过？ 因为配置原因，conf文件夹加一个名为zoo.cfg的配置文件 2、主要是分布式用 练习1，zookeeper和java的结合使用
ZooKeeper 入门看这篇就够了.md
09-23
ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、...
Zookeeper从入门到精通（全）
qq_52252193的博客
06-14 1097
本文主要阐述 zookeeper分布式锁案例 算法Paxos解决一致性算法的问题 ZAB协议进一步解决一致性算法等 1. 概念 zookeeper主要是文件系统和通知机制 文件系统主要是用来存储数据 通知机制主要是服务器或者客户端进行通知，并且监督 基于观察者模式设计的分布式服务管理框架，开源的分布式框架 特点 一个leader，多个follower的集群 集群只要有半数以上包括半数就可正常服务，一般安装奇数台服务器 全局数据一致，每个服务器都保存同样的数据，实时更新 更新的请求顺序保持顺序.
【一篇入魂】Zookeeper入门看这篇就够了
jiaodaguan的博客
12-11 2532
1.1. ZooKeeper 概述 Zookeeper 是一个分布式协调服务的开源框架。主要用来解决分布式集群中 应用系统的一致性问题，例如怎样避免同时操作同一数据造成脏读的问题。 ZooKeeper 本质上是一个分布式的小文件存储系统。提供基于类似于文件系 统的目录树方式的数据存储，并且可以对树中的节点进行有效管理。从而用来维 护和监控你存储的数据的状态变化。通过监控这些数据状态的变化，从而可以...
ZooKeeper系列-基础知识一
qq_28136919的博客
05-14 895
一、ZooKeeper简介 1.1.什么是ZooKeeper ZooKeeper: A Distributed Coordination Service for Distributed Applications ZooKeeper is a distributed, open-source coordination service for distributed applications. It exposes a simple set of primitives that distributed app
zookeeper简单应用&分布式锁实现
JAVA技术爱好者
01-12 318
zookeeper简单应用&分布式锁实现Zookeeper的作用原理特点下载安装安装启动应用节点类型基本的CRUD权限管理ACL配置文件详解zookeeper的客户端原生客户端的使用Curatorzk简单的分布式锁实现 Zookeeper的作用 ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。 Zoo
使用java操作zookeeper(五)
热门推荐
这个名字想了很久
09-27 1万+
原文地址，转载请注明出处：&amp;nbsp;https://blog.csdn.net/qq_34021712/article/details/82872186&amp;nbsp;&amp;nbsp; &amp;nbsp;&amp;nbsp;©王赛超&amp;nbsp; 之前使用的客户端是3.4.6，后来换成了3.5.3-beta 版本，前面的知识中也有对3.5.x一些知识点的补充，往后的客户端版本都使用该版本,下面的介绍也是基于3.5.3-...
ZooKeeper入门
傅红雪的专栏
01-04 191
ZooKeeper是一种用于分布式应用系统的分布式开源协调服务中间件。主要是用来解决分布式应用中经常遇到的一些问题。官网地址：http://zookeeper.apache.org/doc/current/zookeeperOver.html 设计目标 简单的数据模型 高可靠 有序 高性能 简单的数据模型 zk允许各分布式应用通过一个共享的命名空间相互联系，该命名空间类似于一个标准...
zookeeper
苏超凡
03-24 373
1.什么是zookeeper？     ZooKeeper 是一个开源的分布式协调服务，由雅虎创建，是 Google Chubby 的开源实现。分布式应用程序可以基于 ZooKeeper 实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、配置维护，名字服务、分布式同步、分布式锁和分布式队列 zookeeper中的角色 1.leader 2.follewer...
zk实战(一)
sinat_26229211的博客
07-13 554
在之前的文章中ZK集群搭建,中已经将ZK的集群环境搭建好.接下来,我们需要对集群中的一些相关概念做一些解释,以便在之后更好的学习. 集群角色 ​ 在ZK当中总共有三种角色,分别是leader,follower,observer. leader:服务器是整个 zookeeper 集群的核心.主要的工作任务有两项: ​ 1.事物请求的唯一调度和处理者，保证集群事物处理的顺序性集群内部各服务...
Zookeeper 原理与优化
05-31 1万+
Zookeeper 是什么 　Zookeeper 是一个基于 Google Chubby 论文实现的一款解决分布式数据一致性问题的开源实现，方便了依赖 Zookeeper 的应用实现 数据发布 / 订阅、负载均衡、服务注册与发现、分布式协调、事件通知、集群管理、Leader 选举、 分布式锁和队列 等功能 基本概念 集群角色 　一般的，在分布式系统中，构成集群的每一台机器都有自己的...
【从0开始搭建微服务并进行部署】SpringBoot+dubbo+zookeeper
最新发布
高朗的博客
09-29 992
从0开始搭建微服务并进行部署：Springboot+dubbo+zookeeper
Zookeeper入门看这篇就够了
06-01
对于入门 Zookeeper，您可以按照以下步骤进行学习： 1. 了解 Zookeeper 的基本概念：Zookeeper 是一个分布式协调服务，其主要作用是协调分布式系统中的各个节点。Zookeeper 采用了树形数据结构，每个节点都有一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值