ZooKeeper实现分布式FIFO队列

最新推荐文章于 2024-06-19 20:33:32 发布
最新推荐文章于 2024-06-19 20:33:32 发布
阅读量487 收藏
点赞数
分类专栏： 云计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tycoon1988/article/details/38334217
版权

前言

ZooKeeper是一个强大的分布式协作系统，用ZooKeeper可以方便地实现先进先出(FIFO)队列。给“队列”的技术现实多一种选择，标准化我们的程序结构。另一篇，分步式同步队列实现，请参考：ZooKeeper实现分布式队列Queue

关于ZooKeeper的基本使用，请参考：ZooKeeper伪分步式集群安装及使用

目录

  1. 分布式先进先出(FIFO)队列
  2. 设计思路
  3. 程序实现

1. 分布式先进先出(FIFO)队列

在计算机科学中，消息队列（Message queue）是一种进程间通信或同一进程的不同线程间的通信方式。消息队列提供了异步的通信协议，消息的发送者和接收者不需要同时与消息队列互交。消息会保存在队列中，直到接收者取回它。

先进先出(FIFO)队列，是消息队列最基本的一种实现形式，先发出的先消费。

2. 设计思路

实现的思路也非常简单，在/queue-fifo的目录下创建 SEQUENTIAL 类型的子目录 /x(i)，这样就能保证所有成员加入队列时都是有编号的，出队列时通过 getChildren( ) 方法可以返回当前所有的队列中的元素，然后消费其中最小的一个，这样就能保证FIFO。

zookeeper-queue-fifo

应用实例
zookeeper-queue-fifo-app
图标解释

  1. app1,app2,app3是3个独立的业务系统
  2. zk1,zk2,zk3是ZooKeeper集群的3个连接点
  3. /queue-fifo，是znode的队列，按顺序存储数据
  4. /queue-fifo/x1，是znode队列中，1号排对者，由app1提交
  5. /queue-fifo/x2，是znode队列中，2号排对者，由app2提交
  6. app3是消费者，通过zk3连接到znode队列中，找到/queue-fifo中顺序最少的节点消费，删除消费后的节点(红色线表示)

注：

  • 1). app1可以通过zk2提交，app2也可通过zk3提交
  • 2). app1可以提交3次请求，生成x1,x2,x3多个节点
  • 3). app1可以作为消费者，消费队列数据

3. 程序实现

1). 单节点模拟实验

模拟app1，通过zk1，生产2个节点，然后再消费3个节点。


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

创建一个与服务器的连接


    public static ZooKeeper connection(String host) throws IOException {
        ZooKeeper zk = new ZooKeeper(host, 60000, null);
        return zk;
    }

出始化队列


    public static ZooKeeper connection(String host) throws IOException {
        return new ZooKeeper(host, 60000, new Watcher() {
            public void process(WatchedEvent event) {
            }
        });
    }

生产者


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

消费者


    public static void cosume(ZooKeeper zk) throws KeeperException, InterruptedException {
        List list = zk.getChildren("/queue-fifo", true);
        if (list.size() > 0) {
            long min = Long.MAX_VALUE;
            for (String num : list) {
                if (min > Long.parseLong(num.substring(1))) {
                    min = Long.parseLong(num.substring(1));
                }
            }
            System.out.println("delete /queue/x" + min);
            zk.delete("/queue-fifo/x" + min, 0);
        } else {
            System.out.println("No node to cosume");
        }
    }

启动main函数


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

运行结果：


/queue-fifo is exist!
create /queue-fifo/x1 x1
create /queue-fifo/x2 x2
delete /queue/x10000000032
delete /queue/x20000000033
No node to cosume

完全符合我的们预期，由于produce时，我们创建的节点模式是EPHEMERAL_SEQUENTIAL，所以系统会在x(i)(n)，随机生成n=0000000032，输出为x10000000032。

接下来我们看分布式环境。

2). 分布式模拟实验
app1通过zk1生产x1, app2通过zk2生产x2, app3通过zk3消费3个节点


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);
            produce(zk, 1);
            break;
        case 2:
            zk = connection(host2);
            initQueue(zk);
            produce(zk, 2);
            break;
        case 3:
            zk = connection(host3);
            initQueue(zk);
            cosume(zk);
            cosume(zk);
            cosume(zk);
            break;
        }
    }

启动main函数


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

程序启动方法，分3次启动，命令行传不同的参数，分别是1,2,3
run1

run1: 执行app1–>zk1


#日志输出
/queue-fifo is exist!
create /queue-fifo/x1 x1

run2: 执行app2–>zk2


#日志输出
/queue-fifo is exist!
create /queue-fifo/x2 x2

run3: 执行app3–>zk3


#日志输出
/queue-fifo is exist!
delete /queue/x10000000034
delete /queue/x20000000035
No node to cosume

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

下面贴一下完整的代码：


package org.conan.zookeeper.demo;

import java.io.IOException;
import java.util.List;

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

public class FIFOZooKeeper {

    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);
        produce(zk, 1);
        produce(zk, 2);
        cosume(zk);
        cosume(zk);
        cosume(zk);
        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);
            produce(zk, 1);
            break;
        case 2:
            zk = connection(host2);
            initQueue(zk);
            produce(zk, 2);
            break;
        case 3:
            zk = connection(host3);
            initQueue(zk);
            cosume(zk);
            cosume(zk);
            cosume(zk);
            break;
        }
    }

    // 创建一个与服务器的连接
    public static ZooKeeper connection(String host) throws IOException {
        return new ZooKeeper(host, 60000, new Watcher() {
            public void process(WatchedEvent event) {
            }
        });
    }

    public static void initQueue(ZooKeeper zk) throws KeeperException, InterruptedException {
        if (zk.exists("/queue-fifo", false) == null) {
            System.out.println("create /queue-fifo task-queue-fifo");
            zk.create("/queue-fifo", "task-queue-fifo".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            System.out.println("/queue-fifo is exist!");
        }
    }

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

    public static void cosume(ZooKeeper zk) throws KeeperException, InterruptedException {
        List list = zk.getChildren("/queue-fifo", true);
        if (list.size() > 0) {
            long min = Long.MAX_VALUE;
            for (String num : list) {
                if (min > Long.parseLong(num.substring(1))) {
                    min = Long.parseLong(num.substring(1));
                }
            }
            System.out.println("delete /queue/x" + min);
            zk.delete("/queue-fifo/x" + min, 0);
        } else {
            System.out.println("No node to cosume");
        }
    }

}
tycoon1988
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Zookeeper学习：Zookeeper应用场景之分布式队列
小松de博客
10-28 376
1. 分布式队列介绍 分布式队列可以简单分为两大类∶一种是常规的FIFO先入先出队列模型，还有一种是 等待队列元素聚集后统一安排处理执行的Barrier模型。 2. FIFO先入先出 FIFO（First Input First Output，先入先出），FIFO队列是一种非常典型且应用广泛的按序执行的队列模型∶先进入队列的请求操作先完成后，才会开始处理后面的请求。 使用ZooKeeper实现FIFO队列，和之前提到的共享锁的实现非常类似。FIFO队列就类似于一个全写的共享锁模型，大体的设计思路其实非常简单
zookeeper安装以及使用
热门推荐
燕少江湖
07-05 3万+
1、zookeeper简介zookeeper(以下简称ZK)是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop、Hbase、Kafka、Jstorm等开源软件的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。ZK的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功......
Day9 —— 大数据技术之ZooKeeper
最新发布
weixin_62804382的博客
06-19 940
ZooKeeper是一个开源的分布式协调服务，旨在管理和协调分布式应用程序。它提供了一个简单的接口，允许开发人员实现分布式系统中常见的协调任务，如选举、配置管理、命名服务、分布式锁等。
zookeeper快速入门一：zookeeper安装与启动
马不腾的博客
09-29 3万+
本文是《zookeeper你想要的全都有系列》之快速入门中的第一篇，欢迎大家观看与指出不足。 写在前面： 不影响教程，笔者安装zookeeper用的是WSL(windows下的linux子系统），当然你想直接在windows上用zookeeper也是可以的。 如果你也想用wsl，可以参考这篇文章Windows10安装Linux系统(WSL) 目录 一、zookeeper下载 二、安装zookeeper 三、linux下启动zookeeper 四、windows下启动zookeeper 进入
Zookeeper详解（最详细的zookeeper解析+项目实例）
weixin_64105389的博客
11-02 1万+
zooKeeper 是一个开放源码的分布式协调服务，主要为了解决分布式架构下数据一致性问题， 它是集群的管理者， 监视着集群中各个节点的状态，根据节点提交的反馈进行下一步合理操作。 最终， 将简单易用的接口和性能高效、 功能稳定的系统提供给用户
Zookeeper详解
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
09-04 1万+
ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。Zookeeper是Apache的一个java项目，属于Hadoop系统，扮演管理员的角色。它为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。ZooKeeper提供一种集中式服务，用于维护配置信息，命名，提供分布式同步和提供组服务。所有这些类型的服务都以分布式应用程序的某种形式使用。
基于ZooKeeper实现队列
08-29
ZooKeeper中的队列实现主要是通过创建和管理持久化顺序节点（PERSISTENT_SEQUENTIAL）来完成的。当一个生产者想要添加消息到队列中时，它会在指定的父节点下创建一个带有顺序标识的子节点。这些子节点代表了队列中的...
ZooKeeper分布式过程协同技术详解
03-29
- **队列服务**：FIFO（先进先出）的队列可以通过ZNode的顺序创建实现。 3. **ZooKeeper的架构** - **客户端-服务器模型**：每个客户端连接到一个或多个服务器，形成会话，服务器之间通过 zab 协议进行通信和数据...
ZooKeeper-分布式过程协同技术详解
12-25
5. **队列服务**：实现先进先出（FIFO）的队列，常用于消息传递和任务调度。 **四、ZooKeeper的应用场景** 在大数据领域，ZooKeeper广泛应用于Hadoop、HBase、Kafka等组件的协调工作。例如： - **Hadoop**：用于...
zookeeper看这一篇就够了
Andrew_Chenwq的博客
01-04 2411
12341. zookeeper最早起源于雅虎研究院的一个研究小组2. 在雅虎内部很多大型系统基本都需要依赖一个类似的系统来进行分布式协调,并且这个系统还有单点问题3. 雅虎的开发人员就试图开发一个通用的无单点问题的分布式协调框架,以便让开发人员将精力集中在处理业务逻辑上,这是最早zookeeper的原型4. 后来捐献给了apache成为了apache的顶级项目2.1 zk节点概念1。
Zookeeper简介及核心概念
mxk4869的博客
07-19 1万+
Zookeeper简介及核心概念
zookeeper笔记
kyrielx的博客
09-01 3168
zookeeper是一种分布式协调服务，用于管理大型主机。在分布式环境中协调和管理服务是一个复杂的过程，zookeeper通过其简单的架构和API解决了这个问题。zookeeper允许开发人员专注于核心业务逻辑开发，而不必担心应用的分布式特性。Curator是Netflix公司开源的一套zookeeper客户端框架，Curator是对zookeeper支持最好的客户端框架。...
ZooKeeper能做什么？
养歌的博客
12-29 8770
什么是 ZooKeeper ZooKeeper 是一个高性能、集中化、分布式应用程序协调服务，是Hadoop和Hbase的重要组件，主要是用来解决分布式应用中用户经常遇到的一些数据管理问题，例如：统一命名服务、统一配置管理、统一集群管理、分布式锁等。 ZooKeeper 提供一种类似目录树结构的数据结构，跟 Unix 文件系统路径相似的节点，可以往这个节点存储或获取数据，而每个节点叫做 ZNode。每一个节点可以通过路径来标识。 结构图如下： Znode 分为两种类型： 短暂/临时(Ephemeral)：
Zookeeper入门看这篇就够了
chouya7686的专栏
07-12 1万+
Zookeeper是什么 官方文档上这么解释zookeeper，它是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。 上面的解释有点抽象，简单来说z...
基于zookeeper的分布式队列之FIFO队列
Jack博客
10-30 671
2、FIFO队列 fifo就是数据结构中的，first in first out的意思，就是先进先出，这是队列的特点，那么结合队列的特点如何通过zookeeper来实现这个特点了，看图： 1、入队列，我们可以在/queue节点下，不同的客户端创建临时有序节点，通过zookeeper的znode的类型我们知道，有序节点创建时会带编号的，且这个编号的有序递增的，就是为队列的先进创建的条件 2...
Zookeeper：分布式协调服务详解
5. 分布式队列：实现分布式消息队列，如FIFO队列。 总结: Zookeeper作为一款强大的分布式协调服务工具，它简化了分布式环境中的许多复杂问题，如一致性、同步、命名和配置管理。其设计理念和特性使其在大数据、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值