Zookeeper

最新推荐文章于 2024-07-18 13:57:33 发布
最新推荐文章于 2024-07-18 13:57:33 发布
阅读量426 收藏
点赞数
分类专栏： 分布式 文章标签： zookeeper 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingsongxyz/article/details/134456795
版权

一、介绍

ZooKeeper是一个开源的分布式应用程序协调服务，是Hadoop和Hbase的重要组件，提供配置维护、域名服务、分布式同步、分布式锁等功能。

Zookeeper是树形目录结构，和Unix文件系统类似，每一个节点都会保存少量(1MB)数据和节点信息，节点下有子节点。

二、docker安装

1.单机模式

编写配置文件zoo.cfg

# 基本时间单位(ms) 用于维持心跳连接
tickTime=2000
# 客户端连接并同步到服务器的tick时间量
initLimit=5
# 客户端同步到服务器的tick时间量 如果超过会断开会话
syncLimit=2
# 存放数据目录路径
dataDir=../data
# 存放日志目录路径
dataLogDir=../logs
# 客户端连接端口号
clientPort=2181
# 最大客户端连接数
maxClientCnxns=60
# 自动清除会保存dataDir、dataLogDir中的 autopurge.snapRetainCount 最新快照和相应的事务日志，并删除其余快照
# 自动清除任务的时间间隔(以小时为单位)
autopurge.purgeInterval=1
# 自动清除保留的快照数量
autopurge.snapRetainCount=3
# 单机模式
standaloneEnabled=true
# 停用adminServer 8080端口
admin.enableServer=false

docker run -d -p 2181:2181 --name zookeeper --privileged=true
-v /docker/registry/zookeeper/conf:/apache-zookeeper-3.7.1-bin/conf 
-v /docker/registry/zookeeper/data:/apache-zookeeper-3.7.1-bin/data 
-v /docker/registry/zookeeper/logs:/apache-zookeeper-3.7.1-bin/logs 
zookeeper:3.7.1-temurin
​
# 使用zkCli.sh连接
docker exec -it zookeeper zkCli.sh

2.集群模式

zookeeper集群角色：

角色职责
leader处理增删改(事务请求)，同步数据到其他节点
follower处理查询(非事务请求)，参与leader选举
observer处理查询(非事务请求)，缓解follower节点压力，不参与leader选举

编写docker-compose.yaml

version: '3.9'
​
services:
  zoo1:
    image: zookeeper:3.7.1-temurin
    container_name: zoo1
    hostname: zoo1
    ports:
      - 2181:2181
    networks:
      - zookeeper_net
    volumes:
      - /docker/registry/zookeeper/zoo1/conf:/apache-zookeeper-3.7.1-bin/conf
      - /docker/registry/zookeeper/zoo1/data:/apache-zookeeper-3.7.1-bin/data
      - /docker/registry/zookeeper/zoo1/logs:/apache-zookeeper-3.7.1-bin/logs
    environment:
      ZOO_MY_ID: 1
      ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
​
  zoo2:
    image: zookeeper:3.7.1-temurin
    container_name: zoo2
    hostname: zoo2
    ports:
      - 2182:2181
    networks:
      - zookeeper_net
    volumes:
      - /docker/registry/zookeeper/zoo2/conf:/apache-zookeeper-3.7.1-bin/conf
      - /docker/registry/zookeeper/zoo2/data:/apache-zookeeper-3.7.1-bin/data
      - /docker/registry/zookeeper/zoo2/logs:/apache-zookeeper-3.7.1-bin/logs
    environment:
      ZOO_MY_ID: 2
      ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
​
  zoo3:
    image: zookeeper:3.7.1-temurin
    container_name: zoo3
    hostname: zoo3
    ports:
      - 2183:2181
    networks:
      - zookeeper_net
    volumes:
      - /docker/registry/zookeeper/zoo3/conf:/apache-zookeeper-3.7.1-bin/conf
      - /docker/registry/zookeeper/zoo3/data:/apache-zookeeper-3.7.1-bin/data
      - /docker/registry/zookeeper/zoo3/logs:/apache-zookeeper-3.7.1-bin/logs
    environment:
      ZOO_MY_ID: 3
      ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
​
networks:
  zookeeper_net:

docker compose config -q
docker compose up -d

zoo3节点先运行，编号最大，经过选举后称为leader

故障测试

zoo1、zoo2其中一个节点宕机，其余节点均可正常运行，当可运行的节点未超过集群总节点数量的一半时，集群不可用

当zoo1、zoo2重新连接后仍然为follower

当zoo3 leader节点宕机后，会在剩余节点中重新选举出leader，zoo2的序号更大优先级更高选为leader

就算zoo3节点重新连接，会成为follower

三、基本命令

# 进入容器对应bin目录
docker exec -it zookeeper bash
cd bin
​
# 查看当前服务器状态
zkServer.sh status 
# 关闭服务器
zkServer.sh stop
# 开启服务器
zkServer.sh start
# 重启服务器
zkServer.sh restart

帮助命令help：

ls path # 查看路径下的子节点
create [-s] [-e] path data # 创建节点并设置数据 默认为持久节点 -s 指定为顺序节点 -e指定为临时节点当前会话结束后自动删除
get path # 获取节点的数据
set path data # 设置节点的数据
delete path # 删除节点
deleteall path # 删除节点及其子节点

close # 关闭当前连接
connect # 连接服务器
ls -s path #查看节点的子节点和属性信息

创建临时节点：

创建顺序节点：

属性名解释
cZid创建节点的事务id
ctime创建时间
mZxid最后一次更新的事务id
mtime修改时间
pZxid子节点列表最后一次更新的事务id
cversion子节点版本号
dataVersion数据版本号
aclVersion权限版本号
ephemeralOwner临时节点事务id，持久节点为0
dataLength节点存储数据长度
numChildren当前节点子节点个数

四、Java API

1.基本操作
@SpringBootTest
class ZooKeeperApplicationTests {
​
    @Value("${zookeeper.address:localhost:2181}")
    private String address;
​
    @Value("${zookeeper.path:test}")
    private String path;
​
    private CuratorFramework client;
​
    /*
    * 创建连接
    */
    @BeforeEach
    void connect() {
        client = CuratorFrameworkFactory.builder()
                .connectString(address)
                .retryPolicy(new ExponentialBackoffRetry(3000, 10))
                .namespace(path)
                .build();
        client.start();
    }
​
    /*
    * 创建节点 
    * creatingParentsIfNeeded() 创建多级节点
    * CreateMode.EPHEMERAL 创建临时节点在程序执行完毕后 节点自动删除
    */
    @Test
    void createNode() throws Exception {
        //String path = client.create().forPath("/node1"); //默认节点数据为IP地址
        //String path = client.create().forPath("/node1", "1".getBytes(StandardCharsets.UTF_8));
        //String path = client.create().withMode(CreateMode.EPHEMERAL).forPath("/node1", "1".getBytes(StandardCharsets.UTF_8));
        //String path = client.create().withMode(CreateMode.PERSISTENT_SEQUENTIAL).forPath("/node1", "1".getBytes(StandardCharsets.UTF_8));
        String path = client.create().creatingParentsIfNeeded().forPath("/node1/a");
        System.out.println(path);
        System.in.read();
    }
​
    /*
    * 查询节点信息
    */
    @Test
    void getNode() throws Exception {
        Stat status = new Stat();
        byte[] bytes = client.getData().storingStatIn(status).forPath("/node1");
        System.out.println("节点数据: " + new String(bytes));
        System.out.println("节点状态信息: " + status);
​
        List<String> children = client.getChildren().forPath("/node1");
        System.out.println("子节点: " + children);
    }
​
    /*
    * 修改节点信息 withVersion() 携带版本号修改避免并发修改异常(乐观锁)
    */
    @Test
    void setNode() throws Exception {
        Stat status = new Stat();
        byte[] bytes = client.getData().storingStatIn(status).forPath("/node1");
        int version = status.getVersion();
        System.out.printf("原本数据: %s, version: %d\n", new String(bytes), version);
        status = client.setData().withVersion(version).forPath("/node1", "update".getBytes(StandardCharsets.UTF_8));
        bytes = client.getData().storingStatIn(status).forPath("/node1");
        System.out.printf("修改后数据: %s, version: %d", new String(bytes), status.getVersion());
    }
​
    /*
    * 删除节点
    */
    @Test
    void deleteNode() throws Exception {
        client.delete().guaranteed().deletingChildrenIfNeeded().inBackground((client1, event) -> {
            int resultCode = event.getResultCode();
            System.out.println("删除节点是否成功: " + resultCode);
        }).forPath("/node1");
    }
​
​
    /*
    * 断开连接
    */
    @AfterEach
    void close() {
        if (client != null) {
            client.close();
        }
    }
}

测试：

创建节点时未设置数据，默认为IP地址

2.监听
监听方式解释
NodeCache只能监听到对于自身的信息修改、删除
PathChildrenCache只能监听到对于子节点的增删改
TreeCache能监听到自身和子节点的变化
@SpringBootTest
class CuratorWatchTests {
​
    @Value("${zookeeper.address:localhost:2181}")
    private String address;
​
    @Value("${zookeeper.path:test}")
    private String path;
​
    private CuratorFramework client;
​
    /**
    * 创建连接
    */
    @BeforeEach
    void connect() {
        client = CuratorFrameworkFactory.builder()
                .connectString(address)
                .retryPolicy(new ExponentialBackoffRetry(3000, 10))
                .namespace(path)
                .build();
        client.start();
    }
​
    /**
    * NodeCache 创建CuratorCache时需要配置SINGLE_NODE_CACHE 只缓存根节点
    */
    @Test
    void nodeCache() throws Exception {
        CuratorCache curatorCache = CuratorCache.build(client, "/node", CuratorCache.Options.SINGLE_NODE_CACHE);
        CuratorCacheListener listener = CuratorCacheListener.builder().forNodeCache(() -> {
            System.out.println("【NODE_UPDATED】当前节点信息修改...");
        }).build();
​
        curatorCache.listenable().addListener(listener);
        curatorCache.start();
        System.in.read();
    }
​
    /**
    * PathChildrenCache
    */
    @Test
    void pathChildrenCache() throws Exception {
        CuratorCache curatorCache = CuratorCache.build(client, "/path");
        CuratorCacheListener listener = CuratorCacheListener.builder().forPathChildrenCache("/path", client, (client, event) -> {
            PathChildrenCacheEvent.Type eventType = event.getType();
            switch (eventType) {
                case CHILD_ADDED:
                    System.out.println("【CHILD_ADDED】当前节点添加子节点...");
                    break;
                case CHILD_UPDATED:
                    System.out.println("【CHILD_UPDATED】当前节点子节点信息修改...");
                    break;
                case CHILD_REMOVED:
                    System.out.println("【CHILD_REMOVED】当前节点删除子节点");
                    break;
            }
            ChildData childData = event.getData();
            if (childData != null) {
                byte[] d = childData.getData();
                if (d != null && d.length != 0) {
                    System.out.println("《INFO》当前节点信息: " + new String(d));
                }
            }
        }).build();
​
        curatorCache.listenable().addListener(listener);
        curatorCache.start();
        System.in.read();
    }
​
    /**
    * TreeCache
    */
    @Test
    void treeCache() throws Exception {
        CuratorCache curatorCache = CuratorCache.build(client, "/tree", CuratorCache.Options.SINGLE_NODE_CACHE);
        CuratorCacheListener listener = CuratorCacheListener.builder().forTreeCache(client, (client, event) -> {
            ChildData oldData = event.getOldData();
            if (oldData != null) {
                byte[] od = oldData.getData();
                if (od != null && od.length != 0) {
                    System.out.println("《OLD_INFO》当前节点旧信息: " + new String(od));
                }
            }
            TreeCacheEvent.Type eventType = event.getType();
            switch (eventType) {
                case NODE_ADDED:
                    System.out.println("【NODE_ADDED】当前节点添加子节点...");
                    break;
                case NODE_UPDATED:
                    System.out.println("【NODE_UPDATED】当前节点或子节点信息修改...");
                    break;
                case NODE_REMOVED:
                    System.out.println("【NODE_REMOVED】当前节点或子节点删除");
                    break;
            }
            ChildData newData = event.getData();
            if (newData != null) {
                byte[] nd = newData.getData();
                if (nd != null && nd.length != 0) {
                    System.out.println("《NEW_INFO》当前节点新信息: " + new String(nd));
                }
            }
        }).build();
​
        curatorCache.listenable().addListener(listener);
        curatorCache.start();
        System.in.read();
    }
​
    /**
    * new API
    */
    @Test
    void watch() throws Exception {
        CuratorCache curatorCache = CuratorCache.builder(client, "/node1").build();
        CuratorCacheListener listener = CuratorCacheListener.builder()
                .forInitialized(() -> {
                    System.out.println("【INITIALIZED】初始化...");
                })
                .forCreates(childData -> {
                    byte[] data = childData.getData();
                    System.out.println("【NODE_CREATED】新增节点...");
                    if (data != null && data.length != 0) {
                        System.out.println("《INFO》节点信息: " + new String(data));
                    }
                })
                .forChanges((oldNode, newNode) -> {
                    byte[] od = oldNode.getData();
                    byte[] nd = newNode.getData();
                    System.out.println("【NODE_CHANGED】修改节点信息...");
                    if (od != null && od.length != 0) {
                        System.out.println("《INFO》节点旧信息: " + new String(od));
                    }
                    if (nd != null && nd.length != 0) {
                        System.out.println("《INFO》节点新信息: " + new String(nd));
                    }
                })
                //.forCreatesAndChanges() //监听节点创建和修改
                .forDeletes(childData -> {
                    byte[] data = childData.getData();
                    System.out.println("【NODE_DELETED】删除节点...");
                    if (data != null && data.length != 0) {
                        System.out.println("《INFO》节点信息: " + new String(data));
                    }
                })
                .forAll((type, oldData, data) -> {
                    System.out.println("【ALL】节点发生增删改...");
                })
                .build();
​
        curatorCache.listenable().addListener(listener);
        curatorCache.start();
        System.in.read();
    }
​
    /**
    * 断开连接
    */
    @AfterEach
    void close() {
        if (client != null) {
            client.close();
        }
    }
}

测试NodeCache：

测试PathChildrenCache：

测试TreeCache：

测试新API：

五、分布式锁

Zookeeper实现分布式锁流程：

  1. 客户端获取锁，在lock节点下创建临时顺序节点(-es)

  2. 然后获取lock下的所有子节点，如果发现自己创建的子节点序号最小，则认为获取到锁，使用完后，断开连接，临时节点被删除

  3. 如果发现自己创建的子节点序号不是最小的，就找到序号比自己小的相邻的子节点，同时对其监听删除事件

  4. 如果发现比自己小的相邻的子节点被删除，触发监听事件重复2

Curator实现分布式锁：

类介绍
InterProcessMutex可重入锁
InterProcessSemaphoreMutex不可重入锁
InterProcessMultiLock将多个锁作为一个锁使用
InterProcessSemaphoreV2信号量，可以控制同时有多个线程获取锁
InterProcessReadWriteLock读写锁
@Component
public class TicketSeller implements Runnable {
​
    @Value("${zookeeper.address:localhost:2181}")
    private String address;
​
    @Value("${zookeeper.lock-path:/lock}")
    private String lockPath;
​
    private CuratorFramework client;
​
    private static InterProcessLock lock;
​
    private static InterProcessSemaphoreV2 semaphore;
​
    private static InterProcessReadWriteLock readWriteLock;
​
    private static int ticketNumber = 20;
​
    @PostConstruct
    public void init() {
        connect();
        initLock();
    }
​
    @Override
    public void run() {
        boolean acquire = false;
        Lease lease = null;
        try {
            while (true) {
                if (lock != null) {
                    acquire = lock.acquire(1, TimeUnit.SECONDS);
                }
​
                if (semaphore != null) {
                    lease = semaphore.acquire(1, TimeUnit.SECONDS);
                }
​
                if (readWriteLock != null) {
                    acquire = readWriteLock.writeLock().acquire(1, TimeUnit.SECONDS);
                }
​
                if (ticketNumber > 0) {
                    ticketNumber--;
                    System.out.println("窗口-" + Thread.currentThread().getName() + "卖掉一张票, 剩余票数" + ticketNumber);
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            try {
                if (acquire) {
                    if(lock != null) {
                        lock.release();
                    }
​
                    if(readWriteLock != null){
                        readWriteLock.writeLock().release();
                    }
                }
​
                if (lease != null) {
                    lease.close();
                }
                
                TimeUnit.MILLISECONDS.sleep(1000);
​
                if (ticketNumber == 0) {
                    close();
                    System.out.println("票已售空...");
                }
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
​
    private void connect() {
        client = CuratorFrameworkFactory.builder()
                .connectString(address)
                .retryPolicy(new ExponentialBackoffRetry(3000, 10))
                .build();
        client.start();
    }
​
    private void initLock() {
        //1. 可重入锁
        lock = new InterProcessMutex(client, lockPath);
​
        //2. 不可重入锁
        //lock = new InterProcessSemaphoreMutex(client, lockPath);
​
        //3. 将多个锁作为一个锁使用 当调用acquire()时, 将获取所有锁;如果失败,则会释放所获取的所有路径
        //lock = new InterProcessMultiLock(client, Collections.singletonList(lockPath));
​
        //4. 信号量 可以控制同时有多个线程获取锁
        //semaphore = new InterProcessSemaphoreV2(client, lockPath, 3);
​
        //5. 读写锁(可重入) 读锁共享 写锁独占
        //readWriteLock = new InterProcessReadWriteLock(client, lockPath);
    }
​
    private void close() {
        if (client != null) {
            client.close();
        }
    }
}
@SpringBootTest
class TicketSellerTests {
​
    @Autowired
    private TicketSeller ticketSeller;
​
    @Test
    void sell() throws IOException {
        System.out.println("开始售票...");
        new Thread(ticketSeller, "A").start();
        new Thread(ticketSeller, "B").start();
        new Thread(ticketSeller, "C").start();
        System.in.read();
    }
}

测试InterProcessMutex：

测试InterProcessSemaphoreMutex：

测试InterProcessReadWriteLock：

qingsongxyz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zookeeper配置
v15220的博客
06-02 8324
3.修改/创建zookeeper配置文件 1)在zookeeper目录下新建data目录和logs目录 mkdir data logs 在data中新建myid文件，在其中填入数字1（对应zoo.cfg文件的server编号） 2)由于conf目录下没有zoo.cfg文件，所以复制zoo_sample.cfg成zoo.cfg: cp zoo_sample.cfg zoo.cfg 注意一定要删除原有内容后（否则集群会报错myid could not be determined），
zookeeper 3.8.4
05-17
**ZooKeeper 3.8.4：分布式协调服务详解** Apache ZooKeeper 是一个高度可靠的分布式协调服务，广泛应用于大数据、云计算以及微服务等领域的分布式系统中。Zookeeper 3.8.4 版本是该项目的最新稳定版本，提供了一...
ZooKeeper
学习记录和总结
06-05 1万+
ZooKeeper的概述，单体安装以及分布式安装、客户端操作命令以及Java客户端操作
zookeeper集群
weixin_55609824的博客
07-26 1万+
目录一、Zookeeper定义二、 zookeeper工作机制三、zookeeper特点四、Zookeeper数据结构五、zookeeper应用场景六、/l zookeeper选举机制 一、Zookeeper定义 Zookeeper是一个开源的分布式的，为分布式框架提供协调服务的Apache项目。 二、 zookeeper工作机制 Zookeeper从设计模式角度来理解:是一个基于观察者模式设计的分布式服务管理框架它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zooke
Zookeeper概述
亦翼的博客
08-05 2417
文章目录Zookeeper概述工作机制特点数据结构应用场景统一命名服务统一配置管理服务器节点动态上下线软负载均衡下载地址Zookeeper本地模式安装安装前的准备修改配置相关操作配置参数解读Zookeeper内部原理选举机制节点类型监听器原理数据写入流程 Zookeeper概述 百度百科：ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域
ZooKeeper 集群
qq_39144436的博客
03-22 4670
为了保证高可用，最好是以集群形态来部署 ZooKeeper，这样只要集群中大部分机器是可用的（能够容忍一定的机器故障），那么 ZooKeeper 本身仍然是可用的。通常 3 台服务器就可以构成一个 ZooKeeper 集群了。ZooKeeper 官方提供的架构图就是一个 ZooKeeper 集群整体对外提供服务。 上图中每一个 Server 代表一个安装 ZooKeeper 服务的服务器。组成 ZooKeeper 服务的服务器都会在内存中维护当前的服务器状态，并且每台服务器之间都互相保持着通信。集群间
Zookeeper详解
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
09-04 1万+
ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。Zookeeper是Apache的一个java项目，属于Hadoop系统，扮演管理员的角色。它为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。ZooKeeper提供一种集中式服务，用于维护配置信息，命名，提供分布式同步和提供组服务。所有这些类型的服务都以分布式应用程序的某种形式使用。
Zookeeper学习笔记
Morning Sunshine的IT技术博客
03-26 4994
1）Zookeeper是什么 zookeeper，它是一个分布式服务框架，是大数据中的重要组件，它是一个具有高吞吐量的分布式协调系统，它的主要作用是为分布式系统提供协调服务，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。 Dubbo官方推荐使用zookeeoer作为注册中心，注册中心负责服务地址的注册和查找，相当于目录服务。 什么是注册中心？举个简单的例子 ，就像字典目录 ，你要查个字， 找到目录， 然后找到对应的页， 然后字就找到了。 zk也是一个意思，把你要注册的服务给..
zookeeper
yyhzzzzzz的博客
03-29 5349
1.linux下安装完zookeeper之后,进入conf目录编辑zoo.cfg文件,找到dataDir属性更改其路径为zookeeper目录下的zkData文件夹.(因为其默认的目录在Linux下会定清理) (1)进入到zookeeper目录下的bin目录启动zookeeper,使用sh zkServer.sh命令启动zookeeper(或者zkServer.sh start命令启动). (2) 继续在bin目录下使用sh zkCli.sh命令启动zoo...
最新版本zookeeper+dubbo-admin
热门推荐
u013080870的博客
12-04 9万+
下载地址 :https://archive.apache.org/dist/zookeeper/1.去官网下载名字中带有bin的压缩包（就不会出现闪退） 2.将conf目录下zoo_sample.cfg文件重命名为zoo.cfg 3.双击zk.Server.cmd启动程序下载链接：在3.5.5版本后，官方提供了bin的包，可以不需要配置环境，直接上手查看之后以管理员方式启动bin文件夹中的cmd文件会报错，我们需要吧conf里的，zoo_simple复制一份，改成zoo.cofzoo.cfg添加 问题4：出
Zookeeper安装
qq_53862440的博客
11-16 1658
本文介绍了在hadoop环境中配置zookeeper的过程。
zookeeper连接工具
07-05
Zookeeper是一个分布式协调服务，由Apache Hadoop项目开发，广泛应用于大数据生态系统中，如HBase、Kafka等。它提供了一种可靠的方式来管理配置信息、命名服务、分布式同步以及组服务。Zookeeper连接工具则是为了...
zookeeper-3.9.1.zip
12-19
Apache ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，它是集群的管理者，监视着分布式应用程序的运行状态，提供诸如命名服务、配置管理、分布式同步、组服务等分布式基础服务。Zookeeper的设计目标...
zookeeper3.5.5镜像
06-29
zookeeper3.5.5镜像
zookeeper+kafka消息队列群集部署
m0_73868794的博客
07-15 1076
许多消息队列所采用的"插入-获取-删除"范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。例如，在电商系统中，用户下单后，订单处理的消息可以先放入消息队列，后续的库存更新、物流通知等操作可以异步进行，而不必等待每个环节依次完成，从而提高系统的响应速度和整体性能。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。例如，在一些业务流程中，可能需要先处理创建订单的消息，再处理支付订单的消息，消息队列可以保证这种顺序性。
zookeeper+kafka的消息队列
Q7758521adc的博客
07-15 1009
需要注意的是，kafka作为一个支持多生产者多消费者的架构，再写入消息时允许多个生产者写道同一个partition，但是消费者读取的时候一个partition仅允许一个消费者消费，但一个消费者可以消费多个partition。partition的数量决定了组成topic的log的数量， 因此推荐partition的数量要大于同时允许的consumer数量，要小于等于集群broker的数量。offset （偏移量）在消息的生产者与消费之间设置一个系统，负责缓存生产者与消费者之间的消息的缓存。
解决ElasticJob项目重启ZooKeeper注册冲突以及zkCli删除目录
最新发布
heyongjin22的博客
07-18 399
问题原因定时任务使用了代理，默认情况下会读取代理类名称，而不是原始类名称，导致任务名冲突。解决思路自定义一个，在项目重启时，确保读取到的是原始类名称，而不是代理类名称。实现自定义@Override在这里，我们使用方法获取原始类名，这样就避免了代理类引起的冲突问题。
Zookeeper分布式协调服务详解
"Zookeeper教程" Zookeeper是一个广泛使用的开源项目，由Apache软件基金会开发，它设计用于处理大量的分布式系统中的协调任务。作为一个分布式协调服务，Zookeeper的主要目标是简化分布式环境下的数据管理、配置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值