ZooKeeper实现分布式队列Queue

最新推荐文章于 2020-11-19 20:58:01 发布
最新推荐文章于 2020-11-19 20:58:01 发布
阅读量805 收藏
点赞数
分类专栏： 大数据

ZooKeeper是一个分步式的协作系统，何为协作，ZooKeeper价值又有何体现。通过这篇文章的分布式队列的案例，你将了解到ZooKeeper的强大。关于ZooKeeper的基本使用，请参考：ZooKeeper伪分步式集群安装及使用

目录

  1. 分布式队列
  2. 设计思路
  3. 程序实现

1. 分布式队列

队列有很多种产品，大都是消息系统所实现的，像ActiveMQ,JBossMQ,RabbitMQ,IBM-MQ等。分步式队列产品并不太多，像Beanstalkd。

本文实现的分布式对列，是基于ZooKeeper现实的一种同步的分步式队列，当一个队列的成员都聚齐时，这个队列才可用，否则一直等待所有成员到达。

2. 设计思路

创建一个父目录 /queue，每个成员都监控(Watch)标志位目录/queue/start 是否存在，然后每个成员都加入这个队列，加入队列的方式就是创建 /queue/x(i)的临时目录节点，然后每个成员获取 /queue 目录的所有目录节点，也就是 x(i)。判断 i 的值是否已经是成员的个数，如果小于成员个数等待 /queue/start 的出现，如果已经相等就创建 /queue/start。

产品流程图
zookeeper-queue

应用实例
zookeeper-queue-dataprocess

图标解释

  1. app1,app2,app3,app4是4个独立的业务系统
  2. zk1,zk2,zk3是ZooKeeper集群的3个连接点
  3. /queue，是znode的队列，假设队列长度为3
  4. /queue/x1，是znode队列中，1号排对者，由app1提交，同步请求，app1挂载等待
  5. /queue/x2，是znode队列中，2号排对者，由app2提交，同步请求，app2挂起等待
  6. /queue/x3，是znode队列中，3号排对者，由app3提交，同步请求，app3挂起等待
  7. /queue/start，当znode队列中满了，触发创建开始节点
  8. 当/qeueu/start被创建后，app4被启动，所有zk的连接通知同步程序(红色线)，队列已完成，所有程序结束

注：

  • 1). 创建/queue/x1,/queue/x2,/queue/x3没有前后顺序，提交后程序就同步挂起。
  • 2). app1可以通过zk2提交，app2也可通过zk3提交
  • 3). app1可以提交3次请求，生成x1,x2,x3使用队列充满
  • 4). /queue/start被创建后，zk1会监听到这个事件，再告诉app1，队列已完成！

3. 程序实现

1). 单节点模拟实验

模拟app1，通过zk1，提交3个请求


   public static void doOne() throws Exception {
        String host1 = "192.168.1.201:2181";
        ZooKeeper zk = connection(host1);
        initQueue(zk);
        joinQueue(zk, 1);
        joinQueue(zk, 2);
        joinQueue(zk, 3);
        zk.close();
    }

创建一个与服务器的连接


    public static ZooKeeper connection(String host) throws IOException {
        ZooKeeper zk = new ZooKeeper(host, 60000, new Watcher() {
            // 监听/queue/start创建的事件
            public void process(WatchedEvent event) {
                if (event.getPath() != null && event.getPath().equals("/queue/start") && event.getType() == Event.EventType.NodeCreated) {
                    System.out.println("Queue has Completed.Finish testing!!!");
                }
            }
        });
        return zk;
    }

出始化队列


    public static void initQueue(ZooKeeper zk) throws KeeperException, InterruptedException {
        System.out.println("WATCH => /queue/start");
        zk.exists("/queue/start", true);

        if (zk.exists("/queue", false) == null) {
            System.out.println("create /queue task-queue");
            zk.create("/queue", "task-queue".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println("/queue is exist!");
        }
    }

增加队列节点


    public static void joinQueue(ZooKeeper zk, int x) throws KeeperException, InterruptedException {
        System.out.println("create /queue/x" + x + " x" + x);
        zk.create("/queue/x" + x, ("x" + x).getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        isCompleted(zk);
    }

检查队列是否完整


    public static void isCompleted(ZooKeeper zk) throws KeeperException, InterruptedException {
        int size = 3;
        int length = zk.getChildren("/queue", true).size();

        System.out.println("Queue Complete:" + length + "/" + size);
        if (length >= size) {
            System.out.println("create /queue/start start");
            zk.create("/queue/start", "start".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        } 
    }

启动函数main


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

运行结果：


WATCH => /queue/start
/queue is exist!
create /queue/x1 x1
Queue Complete:1/3
create /queue/x2 x2
Queue Complete:2/3
create /queue/x3 x3
Queue Complete:3/3
create /queue/start start
Queue has Completed.Finish testing!!!

完全符合我的们预期。接下来我们看分布式环境

2). 分布式模拟实验

模拟app1通过zk1提交x1,app2通过zk2提交x2,app3通过zk3提交x3


    public static void doAction(int client) throws Exception {
        String host1 = "192.168.1.201:2181";
        String host2 = "192.168.1.201:2182";
        String host3 = "192.168.1.201:2183";

        ZooKeeper zk = null;
        switch (client) {
        case 1:
            zk = connection(host1);
            initQueue(zk);
            joinQueue(zk, 1);
            break;
        case 2:
            zk = connection(host2);
            initQueue(zk);
            joinQueue(zk, 2);
            break;
        case 3:
            zk = connection(host3);
            initQueue(zk);
            joinQueue(zk, 3);
            break;
        }
    }

注：

  • 1). 为了简单起见，我们没有增加复杂的多线程控制的机制。
  • 2). 没有调用zk.close()方法，也就是说，app1执行完单独的提交，app1就结束了，但zk1还存在着，所以/queue/x1存在于队列。
  • 3). 程序启动方法，分3次启动，命令行传不同的参数，分别是1,2,3

zk-run1

执行app1–>zk1


#日志输出
WATCH => /queue/start
/queue is exist!
create /queue/x1 x1
Queue Complete:1/3

#zookeeper控制台
[zk: 192.168.1.201:2181(CONNECTED) 4] ls /queue
[x10000000011]

执行app2–>zk2


#日志输出
WATCH => /queue/start
/queue is exist!
create /queue/x2 x2
Queue Complete:2/3

#zookeeper控制台
[zk: 192.168.1.201:2181(CONNECTED) 5] ls /queue
[x20000000012, x10000000011]

执行app3–>zk3


#日志输出
WATCH => /queue/start
/queue is exist!
create /queue/x3 x3
Queue Complete:3/3
create /queue/start start
Queue has Completed.Finish testing!!!

#zookeeper控制台
[zk: 192.168.1.201:2181(CONNECTED) 6] ls /queue
[x30000000016, x10000000014, start, x20000000015]

/queue/stats被建立，打印出“Queue has Completed.Finish testing!!!”，代表调用app4完成！

我们完成分布式队列的实验，由于时间仓促。文字说明及代码难免有一些问题，请发现问题的同学帮忙指正。

下面贴一下完整的代码：


package org.conan.zookeeper.demo;

import java.io.IOException;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.ZooDefs.Ids;

public class QueueZooKeeper {

    public static void main(String[] args) throws Exception {
        if (args.length == 0) {
            doOne();
        } else {
            doAction(Integer.parseInt(args[0]));
        }
    }

    public static void doOne() throws Exception {
        String host1 = "192.168.1.201:2181";
        ZooKeeper zk = connection(host1);
        initQueue(zk);
        joinQueue(zk, 1);
        joinQueue(zk, 2);
        joinQueue(zk, 3);
        zk.close();
    }

    public static void doAction(int client) throws Exception {
        String host1 = "192.168.1.201:2181";
        String host2 = "192.168.1.201:2182";
        String host3 = "192.168.1.201:2183";

        ZooKeeper zk = null;
        switch (client) {
        case 1:
            zk = connection(host1);
            initQueue(zk);
            joinQueue(zk, 1);
            break;
        case 2:
            zk = connection(host2);
            initQueue(zk);
            joinQueue(zk, 2);
            break;
        case 3:
            zk = connection(host3);
            initQueue(zk);
            joinQueue(zk, 3);
            break;
        }
    }

    // 创建一个与服务器的连接
    public static ZooKeeper connection(String host) throws IOException {
        ZooKeeper zk = new ZooKeeper(host, 60000, new Watcher() {
            // 监控所有被触发的事件
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeCreated && event.getPath().equals("/queue/start")) {
                    System.out.println("Queue has Completed.Finish testing!!!");
                }
            }
        });
        return zk;
    }

    public static void initQueue(ZooKeeper zk) throws KeeperException, InterruptedException {
        System.out.println("WATCH => /queue/start");
        zk.exists("/queue/start", true);

        if (zk.exists("/queue", false) == null) {
            System.out.println("create /queue task-queue");
            zk.create("/queue", "task-queue".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println("/queue is exist!");
        }
    }

    public static void joinQueue(ZooKeeper zk, int x) throws KeeperException, InterruptedException {
        System.out.println("create /queue/x" + x + " x" + x);
        zk.create("/queue/x" + x, ("x" + x).getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        isCompleted(zk);
    }

    public static void isCompleted(ZooKeeper zk) throws KeeperException, InterruptedException {
        int size = 3;
        int length = zk.getChildren("/queue", true).size();

        System.out.println("Queue Complete:" + length + "/" + size);
        if (length >= size) {
            System.out.println("create /queue/start start");
            zk.create("/queue/start", "start".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        } 
    }

}

meiye
关注
专栏目录
Zookeeper分布式消息队列实现详解
AI天才研究院
02-16 95
1. 背景介绍 1.1 分布式系统的挑战 随着互联网技术的快速发展，分布式系统已经成为了当今企业和开发者的首选架构。然而，分布式系统带来的高可用性、高性能和可扩展性的同时，也带来了诸多挑战，如数据一致性、分布式事务、服务发现等问题。为了解决这些问题，业界提出了许多解决方案，其中之一便是分布式消息队列
ZooKeeper 实现分布式队列
jerome
08-27 1583
在传统的单进程编程中，我们使用队列来存储数据结构，用来在多线程之间共享或者传递数据。在分布式环境下，同样需要一个类似单进程的组件， 用来实现跨进程、跨主机、跨网络的数据共享和数据传递。这就是我们的分布式队列。Zookeeper可以通过顺序节点来实现分布式队列。
zookeeper实现分布式队列
mjlfto的博客
01-22 525
zookeeper实现分布式队列 利用zookeeper的有序节点和节点一旦被删除，其他连接就不能重复删除的特性实现一个非常简单的分布式队列，说实话，我觉得用zookeeper实习分布式队列并不合适，而且我这里实现的也是最简单的，效率也不高 实现细节，利用create -s /queue/q_创建有序节点，这样数据就放到队列了，当然这一步是使用zookeeper的客户端Curator实现的，然后取...
zookeeper的barriers和queue简单案例
koflance的博客
11-22 856
1、介绍应该都用过jdk自带的countdownlatch、cyclicbarrier和queue，都知道前者是一个可循环使用的多线程同步栅栏，后者是一个队列，用于常用于异步操作。但在分布式环境下如何做到用barrier进行同步多台机器实例的运行？如何进行队列消费？也许想到了消息队列jmx，或者用redis等分布式nosql缓存做同步，但其实zookeeper也可以，只要好好使用好getChildr
ZooKeeper实现分布式队列详解
在Zookeeper中实现分布式队列，通常会创建一个父节点作为队列节点，例如"queue-node"。每个客户端通过调用Zookeeper的`create()`方法，创建路径以"qn-"结尾且带有顺序标志的节点。这样创建的节点路径将会是如"queue-...
zookeeper 实现分布式队列
惜暮
03-19 2303
zookeeper是一种高性能，可扩展的服务。其本身提供了一致性保证，特点如下：（1）顺序一致性：客户端的更新顺序与它们被发送的顺序一致。（2）原子性：更新操作要么成功，要么失败，没有第三种结果。（3）单系统镜像：无论客户端连接到哪一个服务器，他都将看到相同的zookeeper视图。（4）可靠性：一旦一个更新操作被应用，那么在客户端再次更新之前，其值不会再改变。zookeeper实现分布式队列基于
Zookeeper应用之——队列（Queue）
weixin_33994429的博客
07-03 204
Zookeeper应用之——队列（Queue） 为了在Zookeeper中实现分布式队列，首先需要设计一个znode来存放数据，这个节点叫做队列节点，我们的例子中这个节点是/zookeeper/queue。 生产者向队列中存放数据，每一个消息都是队列节点下的一个新节点，叫做消息节点。消息节点的命名规则为：qu...
zookeeper实现队列_Queue
weixin_33964094的博客
03-18 117
为什么80%的码农都做不了架构师？>>> ...
基于zookeeper的分布式Queue
ZERO
10-22 625
原理：ZooKeeper通过一个Node来维护Queue的实体，用其children来存储Queue的内容，并且ZooKeeper的create方法中提供了顺序递增的模式，会自动地在name后面加上一个递增的数字来插入新元素。可以用其children来构建一个queue的数据结构，offer的时候使用create，take的时候按照children的顺序删除第一个即可。ZooKeeper保障了各个
ZooKeeper-ExpiryQueue详解
WillYang的博客
08-24 570
ZooKeeper服务端管理客户端会话超时使用到ExpiryQueue，该数据结构在管理超时连接时的使用还比较巧妙，在这里还是研究一下，以供以后参考使用。
zookeeper的学习（一）：实现分布式队列queue
迪迪调调的博客
06-25 1066
算法流程图： 核心方法的简要概述： 1.offer方法 在zookeeper下创建临时顺序节点。 2 poll方法 由于队列的先进先出特性，所以poll方法，就是读取zookeeper队列节点下所有子节点最小number的那个节点，读到数据， 则返回且删除该节点 代码： package com.zk.queue; import java.util.Collecti...
ZK编程 - 基础教程 - 使用 ZooKeeper 实现Queue 和 Barrier
sparrowxin的博客
11-19 449
ZK编程 - 基础教程 - 实现Queue 和 BarrierZK编程 - 基础教程前言介绍Barriers生产者-消费者队列测试Queue 测试Barrier 测试源代码 ZK编程 - 基础教程 前言 翻译自官网 介绍 这个教程实现了 障栅(barriers) 和 生产-消费者队列(producer-consumer queues). 分别对应代码里面的 Barrier 和 Queue类, 运行这个例子需要至少一个 ZK 服务器. 两个类都使用下面这个基类: static ZooKeeper zk =
分布式消息队列浅析
nellson的专栏
12-21 3913
队列作为一种比较抽象的数据结构，在程序世界中被广泛的应用，而实现方式和形态也各式各样，有使用进程内堆栈实现的，如stl库中的queue;有基于管道、Shmem实现的，如常见的同机进程间通信模型，而随着分布式系统应用越来越广泛，跨机通信的场景需来需多，面临的问题不仅是消息投递问题，分布式系统普适性的挑战也随着应用场景的多样性而越来越多。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值