Zookeeper的几个简单应用

最新推荐文章于 2023-03-21 21:41:01 发布
最新推荐文章于 2023-03-21 21:41:01 发布
阅读量116 收藏
点赞数
分类专栏： Zookeeper Hadoop 文章标签： zookeeper 大数据 java hadoop
原文链接：https://www.cnblogs.com/sunddenly/p/4092654.html
版权

转载于ZooKeeper学习第五期

分布式锁

实现Watcher接口，作为以下几个应用的父类TestMainClient.java。

package com.xcy.ZK;

import org.apache.log4j.xml.DOMConfigurator;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.io.IOException;


public class TestMainClient implements Watcher {
    protected static ZooKeeper zk = null;
    protected static Integer mutex;
    int sessionTimeout = 10000;
    protected String root;
    public TestMainClient(String connectString) {
        if(zk == null){
            try {

                String configFile = this.getClass().getResource("/").getPath()+"org/zk/leader/election/log4j.xml";
                DOMConfigurator.configure(configFile);
                System.out.println("创建一个新的连接:");
                zk = new ZooKeeper(connectString, sessionTimeout, this);
                mutex = new Integer(-1);
            } catch (IOException e) {
                zk = null;
            }
        }
    }
    //synchronized：保证在同一时刻，只有一个线程可以执行某个方法或某个代码块
    synchronized public void process(WatchedEvent event) {
        synchronized (mutex) {
            mutex.notify();
            //唤醒一个等待（对象的）线程并使该线程开始执行
        }
    }
}

Locks.java

package com.xcy.ZK;

import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.Stat;


import java.util.Arrays;
import java.util.List;


public class Locks extends TestMainClient {
    public static final Logger logger = Logger.getLogger(Locks.class);
    String myZnode;

    public Locks(String connectString, String root) {
        super(connectString);
        this.root = root;
        if (zk != null) {
            try {
                Stat s = zk.exists(root, false);
                if (s == null) {
                    zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                }
            } catch (KeeperException e) {
                logger.error(e);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }
    }
    //查看是否拿到锁
    void getLock() throws KeeperException, InterruptedException{
        List<String> list = zk.getChildren(root, false);
        String[] nodes = list.toArray(new String[list.size()]);
        Arrays.sort(nodes);
        //拿到锁
        if(myZnode.equals(root+"/"+nodes[0])){
            doAction();
        }
        else{
            waitForLock(nodes[0]);
        }
    }
    //抢锁
    void check() throws InterruptedException, KeeperException {
        myZnode = zk.create(root + "/lock_" , new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
        getLock();
    }
    //线程等待，等待
    void waitForLock(String lower) throws InterruptedException, KeeperException {
        Stat stat = zk.exists(root + "/" + lower,true);//监控节点，如果拿到最小号节点，就从服务器通知到该线程，执行process
        if(stat != null){
            mutex.wait();
        }
        else{
            getLock();
        }
    }
    @Override
    //确认已经拿到了最小节点
    public void process(WatchedEvent event) {
        if(event.getType() == Event.EventType.NodeDeleted){
            System.out.println("得到通知");
            super.process(event);
            doAction();
        }
    }
    /**
     * 执行其他任务
     */
    private void doAction(){
        System.out.println("同步队列已经得到同步，可以开始执行后面的任务了");
    }
    //每个线程（客户机）都同时执行。
    public static void main(String[] args) {
        String connectString = "localhost:2181";

        Locks lk = new Locks(connectString, "/locks");//创建父节点
        try {
            lk.check();
        } catch (InterruptedException e) {
            logger.error(e);
        } catch (KeeperException e) {
            logger.error(e);
        }
    }
}

Master选举

LeaderElection.java

package com.xcy.ZK;

import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.Stat;

import java.net.InetAddress;
import java.net.UnknownHostException;


public class LeaderElection extends TestMainClient {
    public static final Logger logger = Logger.getLogger(LeaderElection.class);

    public LeaderElection(String connectString, String root) {
        super(connectString);
        this.root = root;
        if (zk != null) {
            try {
                Stat s = zk.exists(root, false);
                if (s == null) {
                    zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                }
            } catch (KeeperException e) {
                logger.error(e);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }
    }

    void findLeader() throws InterruptedException, UnknownHostException, KeeperException {
        byte[] leader = null;
        //判断当前leader是否已被其他线程创建，且向服务器注册watch，若以后有注册就通知改线程。
        try {
            leader = zk.getData(root + "/leader", true, null);
        } catch (KeeperException e) {
            if (e instanceof KeeperException.NoNodeException) {
                logger.error(e);
            } else {
                throw e;
            }
        }
        //当前已被创建，直接作为follower。
        if (leader != null) {
            following();
        } else {
            String newLeader = null;
            byte[] localhost = InetAddress.getLocalHost().getAddress();
            //试图创建leader节点
            try {
                newLeader = zk.create(root + "/leader", localhost, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            } catch (KeeperException e) {
                if (e instanceof KeeperException.NodeExistsException) {
                    logger.error(e);
                } else {
                    throw e;
                }
            }
            //若成功创建后，成为领导者，同时服务器通知到其他wait中的线程启动执行process；否则进入线程等待，给其他线程让位。
            if (newLeader != null) {
                leading();
            } else {
                mutex.wait();
            }
        }
    }

    @Override
    //传来噩耗，被其他线程成功创建了领导者，自己只能作为follower
    public void process(WatchedEvent event) {
        if (event.getPath().equals(root + "/leader") && event.getType() == Event.EventType.NodeCreated) {
            System.out.println("得到通知");
            super.process(event);
            following();
        }
    }

    void leading() {
        System.out.println("成为领导者");
    }

    void following() {
        System.out.println("成为组成员");
    }

    public static void main(String[] args) {
        String connectString = "localhost:2181";

        LeaderElection le = new LeaderElection(connectString, "/GroupMembers");//创建父节点
        try {
            le.findLeader();
        } catch (Exception e) {
            logger.error(e);
        }
    }
}

队列管理

  • 同步队列
    Synchronizing.java
package com.xcy.ZK;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;

import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.Stat;


public class Synchronizing extends TestMainClient {
    int size;
    String name;
    public static final Logger logger = Logger.getLogger(Synchronizing.class);

    /**
     * 构造函数
     *
     * @param connectString 服务器连接
     * @param root 根目录
     * @param size 队列大小
     */
    Synchronizing(String connectString, String root, int size) {
        super(connectString);
        this.root = root;
        this.size = size;

        if (zk != null) {
            try {
                Stat s = zk.exists(root, false);
                if (s == null) {
                    zk.create(root, new byte[0], Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
                }
            } catch (KeeperException e) {
                logger.error(e);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }
        try {
            name = new String(InetAddress.getLocalHost().getCanonicalHostName().toString());
        } catch (UnknownHostException e) {
            logger.error(e);
        }

    }

    /**
     * 加入队列
     *
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */

    void addQueue() throws KeeperException, InterruptedException{
        //判断当前start节点是否存在，并注册watch。
        zk.exists(root + "/start",true);
        //创建节点（即加入队列），临时、有序号。
        zk.create(root + "/" + name, new byte[0], Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
        //同时只能由一个线程执行这个代码块。
        synchronized (mutex) {
            List<String> list = zk.getChildren(root, false);
            //若队列成员小于成员总数，线程进入等待；否则可以创建start节点，永久、无序号，同时通知等待中的线程执行process。
            if (list.size() < size) {
                mutex.wait();
            } else {
                zk.create(root + "/start", new byte[0], Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
            }
        }
    }

    @Override
    //传来命令，最后一个入队列的线程创建了start节点，可以执行任务了。
    public void process(WatchedEvent event) {
        if(event.getPath().equals(root + "/start") && event.getType() == Event.EventType.NodeCreated){
            System.out.println("得到通知");
            super.process(event);
            doAction();
        }
    }

    /**
     * 执行其他任务
     */
    private void doAction(){
        System.out.println("同步队列已经得到同步，可以开始执行后面的任务了");
    }

    public static void main(String args[]) {
        //启动Server
        String connectString = "localhost:2181";
        int size = 1;
        Synchronizing b = new Synchronizing(connectString, "/synchronizing", size);//创建父节点
        try{
            b.addQueue();
        } catch (KeeperException e){
            logger.error(e);
        } catch (InterruptedException e){
            logger.error(e);
        }
    }
}
  • FIFO队列
    FIFOQueue.java
package com.xcy.ZK;

import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.data.Stat;

import java.nio.ByteBuffer;
import java.util.List;


public class FIFOQueue extends TestMainClient{
    public static final Logger logger = Logger.getLogger(FIFOQueue.class);

    /**
     * Constructor
     *
     * @param connectString
     * @param root
     */
    FIFOQueue(String connectString, String root) {
        super(connectString);
        this.root = root;
        if (zk != null) {
            try {
                Stat s = zk.exists(root, false);
                if (s == null) {
                    zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
                }
            } catch (KeeperException e) {
                logger.error(e);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }
    }
    /**
     * 生产者
     *
     * @param i
     * @return
     */

    boolean produce(int i) throws KeeperException, InterruptedException{
        //将i转化为字节数组
        ByteBuffer b = ByteBuffer.allocate(4);
        byte[] value;
        b.putInt(i);
        value = b.array();
        zk.create(root + "/element", value, ZooDefs.Ids.OPEN_ACL_UNSAFE,
                CreateMode.PERSISTENT_SEQUENTIAL);//生产永久、有序号的节点
        return true;
    }


    /**
     * 消费者
     *
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    int consume() throws KeeperException, InterruptedException{
        int retvalue = -1;
        Stat stat = null;
        //循环执行，保障被唤醒的消费者能继续消费。
        while (true) {
            //保证只有一个线程运行该代码块
            synchronized (mutex) {
                //注册watch，返回值有变化时通知线程苏醒。
                List<String> list = zk.getChildren(root, true);
                //若当前没有产品，线程进入等待；否则。
                if (list.size() == 0) {
                    mutex.wait();
                } else {
                    Integer min = new Integer(list.get(0).substring(7));//获取一个序号
                    //循环得到最小序号
                    for(String s : list){
                        Integer tempValue = new Integer(s.substring(7));
                        if(tempValue < min) min = tempValue;
                    }
                    //拿到最小序号对应的产品的字节数组
                    byte[] b = zk.getData(root + "/element" + min,false, stat);
                    //删除拿到的产品（节点）
                    zk.delete(root + "/element" + min, 0);
                    ByteBuffer buffer = ByteBuffer.wrap(b);
                    retvalue = buffer.getInt();//转为整型
                    return retvalue;
                }
            }
        }
    }

    @Override
    //被通知苏醒
    public void process(WatchedEvent event) {
        super.process(event);
    }

    public static void main(String args[]) {
        //启动Server
        TestMainServer.start();
        String connectString = "localhost:"+TestMainServer.CLIENT_PORT;

        FIFOQueue q = new FIFOQueue(connectString, "/app1");//创建父节点
        int i;
        Integer max = new Integer(5);

        System.out.println("Producer");
        for (i = 0; i < max; i++) {
            try {
                q.produce(10 + i);
            } catch (KeeperException e) {
                logger.error(e);
            } catch (InterruptedException e) {
                logger.error(e);
            }
        }
        for (i = 0; i < max; i++) {
            try{
                int r = q.consume();
                System.out.println("Item: " + r);
            } catch (KeeperException e){
                i--;
                logger.error(e);
            } catch (InterruptedException e){
                logger.error(e);
            }
        }

    }
}

代码来源于转载，博主仅仅加了点注释 。

暗香 残留
关注
专栏目录
Zookeeper 集群的应用场景
将臣三代的博客
06-19 1141
Zookeeper 是一个分布式协调服务，主要用于管理分布式应用中的配置、同步和命名等任务。由于其高可用性、一致性和可靠性，Zookeeper 被广泛应用于各种分布式系统中。
大数据笔记--Zookeeper（第二篇）
我睡觉的时候不困
03-09 904
目录 一、Zookeeper 1、概述 2、安装 3、伪分布式安装 4、特点 5、命令 6、节点信息 7、节点类型 8、zookeeper-API i、普通API无观察者 ii、观察者API 二、完全分布式安装 1、三台服务器准备 2、安装Zookeeper 3、完成效果 一、Zookeeper 1、概述 ①、Zookeeper是Yahoo（雅虎）开发后来贡献给了Apache的一套用于分布式管理和协调的框架 ②、Zookeeper本身仿照Google的《The C.
Zookeeper（传统客户端，zkClient，Curator）三种客户端连接操作
踟蹰千年的博客
04-01 1364
Zookeeper传统客户端 新建maven工程 加入依赖 <dependencies> <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId...
【zookeeper】客户端API操作
qq_70770395的博客
03-21 900
1.3
zookeeper 安装 和 常用命令 及 （IDEA）通过java实现其 增删改查
qq_57381370的博客
04-06 2182
zookeeper安装 (5条消息) zookeeper是什么？ 和 centos8 安装zookeeper_阿A轲的博客-CSDN博客 --------------------------------------------------------------------------------------------------------------------------------- zookeeper的常用命令 1. 显示根目录下、文件： ls / 使用 ls 命令来查看当前 ZooK
深入浅出Zookeeper之三Exists请求和处理
吊丝码农
12-27 2290
 前一篇介绍了zookeeper的client和server之间session是如何建立的。在DataMonitor的例子中，DataMonitor通过exists异步接口和server端交互，本文将介绍exists操作是如何完成。 dataMonitor开始exist操作   public void exists(final String path, Watcher watcher...
大数据技术基础实验报告-Zookeeper的安装配置和应用实践.doc
08-21
Apache ZooKeeper 是一个分布式的，开放源码的分布式应用程序协调服务，它是集群的管理者，监视着集群中各个节点的状态根据节点提交的反馈进行下一步合理操作。最终将简单易用的接口和性能高效、功能稳定的系统提供...
spring dubbo zookeeper实现简单demo
01-30
本示例将深入解析如何使用Spring Dubbo与Zookeeper共同实现一个简单的服务发现和调用的Demo。 首先，Spring Dubbo是一款由阿里巴巴开发的高性能、轻量级的Java RPC框架，它提供了服务治理的一系列功能，包括服务...
1、zookeeper3.7.1安装与验证
最新发布
05-29
在本文中，我们将深入探讨Zookeeper 3.7.1的安装和验证过程，主要涉及以下几个方面： 1. **环境准备**： 在安装Zookeeper之前，你需要确保你的系统是CentOS 6，并且已经安装了JDK 8。因为Zookeeper需要非root用户...
training-zookeeper:练习使用Java调用ZooKeeper，zookeeper主要用来分布式锁的应用配置，dubbo中就使用了zookeeper保存注册中心各个应用的配置情况
06-06
在深入学习ZooKeeper时，我们需要理解以下几个核心概念： 1. **ZNode**：ZooKeeper中的数据单元，每个ZNode都有一个唯一的路径标识。 2. **Watch机制**：一种一次性触发的通知机制，用于监听ZNode的变化。 3. **...
zookeeper java 客户端_Zookeeper 客户端 Api 的基本使用
weixin_35733151的博客
02-16 158
零 版本JDK 版本 : OpenJDK 11.0.1IDE : idea 2018.3Zookeeper Server 版本 : 3.5.4-betaZookeeper Client 版本 : 3.5.4-betaCurator 版本 : 4.2.0一 Zookeeper ClientZookeeper Client 是 Zookeeper 的经典原生客户端。使用之前需要在 Maven 中导入依...
[zookeeper]zookeeper系列五：zookeeper自带客户端原生api的使用
zkp_java的专栏
09-18 1446
引入依赖 zookeeper中自带一个客户端，只需要引入zookeeper，在build.gradle中添加以下依赖即可： compile ('org.apache.zookeeper:zookeeper:3.4.13') 创建zookeeper会话 org.apache.zookeeper.ZooKeeper类的构造方法用于创建zookeeper客户端与服务端之间的会话。该类提供了如下几个构造...
(4)zookeeper原生java api基本使用介绍
没头脑遇到不高兴
09-18 3412
本节介绍 本节里面，将会利用zookeeper官方的原生java api进行连接，然后演示一些创建、删除、修改、查询节点的操作。其实有两个比较好用的第三方客户端zkclient和curator，可以弥补原生api的很多不足，使用也比较简便，但是这两个东西也都是在原生api的基础上封装的，所以了解原生api的使用方法还是很有必要的，后面有时间的话会跟大家介绍一下另外两个客户端。 zookeepe...
记录Zookeeper编译源码出现 找不到org.apache.zookeeper.data 的问题
m0_47455313的博客
02-06 3845
主要是因为maven依赖未正常加载,重新编译jute即可
Zookeeper客户端API之创建节点（七）
热门推荐
程序新视界
03-24 1万+
本篇博客主要讲一下使用Zookeeper原生的客户API来创建一个数据节点。 创建数据节点方法 Zookeeper提供了两个创建数据节点的方法。 同步创建数据节点方法： public String create(final String path, byte data[], List acl, CreateMode createMode) throw
Zookeeper入门看这篇就够了
chouya7686的专栏
07-12 1万+
Zookeeper是什么 官方文档上这么解释zookeeper，它是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。 上面的解释有点抽象，简单来说z...
ZooKeeper 常用操作API详解
haihongazar的博客
09-19 4822
转载：http://www.aboutyun.com/thread-12817-1-1.html 问题导读： 1、ZooKeeper的常用API方法都有那些？ 2、Zookeeper 到底能帮我们解决那些问题？ 3、如何实现共享锁（Locks）？   ZooKeeper是一个用于分布式应用程序的分布式开源协调服务。它使用一组简单的操作原语，使得分布式应用可以实现更高层
Zookeeper——2、使用Zookeeper原生API操作Zookeeper
隔壁老王的专栏
12-02 1万+
zookeeper的javaclient可以使我们更轻松的实现对zookeeper的各种操作，要使用java操作zookeeper，需要引入zookeeper-3.4.5.jar和zkclient-0.1.jar。zookeeper-3.4.5.jar是官方提供的JAVA API，zkclient-0.1.jar则是在原生API基础上进行扩展的开源Java客户端。 客户端可以通过创建一个zook
分布式助手Zookeeper（五）
三劫散仙
12-05 136
[b][color=olive][size=large]散仙在上篇文章分享了关于使用zookeeper来完成配置同步的功能，那么本篇，散仙依旧是模拟实现一个基于zookeeper怎么解决单点故障的案例。 单点故障问题，在分布式系统中是一个很有可能发生的场景，比如说在Hadoop2.x之前的HDFS的NameNode和MapReduce的JobTracker的单点故障，当然这个问题已经在Hadoo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值