ZooKeeper学习笔记十一 ZooKeeper典型应用场景——分布式队列

其他 2018-08-19 11:20:22 阅读次数: 0

本文学习资源来自《从Paxos到ZooKeeper分布式一致性原理与实践》 电子工业出版社

分布式队列，简单地讲有两大类：一种是常规的先入先出队列，另一种则是要等到队列元素集聚之后才统一安排执行的Barrier模型 （同步队列）。

FIFO：先入先出

先入先出的算法思想，以其简单明了的特点，广泛应用于计算机科学的各个方面。而FIFO队列也是一种非常典型且应用广泛的按序执行的队列模型；先进入队列的请求操作先完成后，才会开始处理后面的请求。

使用ZooKeeper实现FIFO队列，和共享锁的实现非常类似。FIFO队列就类似于一个全写的共享锁模型，大体设计思路：
所有客户端都会到/queue_fifo这个节点下面创建一个临时顺序节点，例如/queue_fifo/192.168.0.1-00000001，
创建完节点之后，根据如下4个步骤来确定执行顺序：

  1. 通过调用getChildren()接口来获取/queue_fifo节点下的所有子节点，即获取队列中所有的元素
  2. 确定自己的节点序号在所有子节点中的顺序
  3. 如果自己不是序号最小的子节点，那么就需要进入等待，同时向比自己序号小的最后一个节点注册Watcher监听。
  4. 接收到Wathcer通知后，重复步骤1

代码示例：
这里写图片描述

DistributedQueue

package zookeeper;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.I0Itec.zkclient.ExceptionUtil;
import org.I0Itec.zkclient.exception.ZkNoNodeException;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 分布式队列，同步队列的实现
 * 
 * @author linbingwen
 *
 * @param <T>
 */
public class DistributedQueue<T> {
    private static Logger logger = LoggerFactory.getLogger(DistributedQueue.class);

    protected final ZooKeeper zooKeeper;// 用于操作zookeeper集群
    protected final String root;// 代表根节点
    private int queueSize;
    private String startPath = "/queue/start";

    protected static final String Node_NAME = "n_";// 顺序节点的名称

    public DistributedQueue(ZooKeeper zooKeeper, String root, int queueSize) {
        this.zooKeeper = zooKeeper;
        this.root = root;
        this.queueSize = queueSize;
        init();
    }

    /**
     * 初始化根目录
     */
    private void init() {
        try {
            Stat stat = zooKeeper.exists(root, false);// 判断一下根目录是否存在
            if (stat == null) {
                zooKeeper.create(root, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
            zooKeeper.delete(startPath, -1); // 删除队列满的标志
        } catch (Exception e) {
            logger.error("create rootPath error", e);
        }
    }

    /**
     * 获取队列的大小
     * 
     * @return
     * @throws Exception
     */
    public int size() throws Exception {
        return zooKeeper.getChildren(root, false).size();
    }

    /**
     * 判断队列是否为空
     * 
     * @return
     * @throws Exception
     */
    public boolean isEmpty() throws Exception {
        return zooKeeper.getChildren(root, false).size() == 0;
    }

    /**
     * bytes 转object
     * 
     * @param bytes
     * @return
     */
    private Object ByteToObject(byte[] bytes) {
        Object obj = null;
        try {
            // bytearray to object
            ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
            ObjectInputStream oi = new ObjectInputStream(bi);

            obj = oi.readObject();
            bi.close();
            oi.close();
        } catch (Exception e) {
            logger.error("translation" + e.getMessage());
            e.printStackTrace();
        }
        return obj;
    }

    /**
     * Object 转byte
     * 
     * @param obj
     * @return
     */
    private byte[] ObjectToByte(java.lang.Object obj) {
        byte[] bytes = null;
        try {
            // object to bytearray
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);

            bytes = bo.toByteArray();

            bo.close();
            oo.close();
        } catch (Exception e) {
            logger.error("translation" + e.getMessage());
            e.printStackTrace();
        }
        return bytes;
    }

    /**
     * 向队列提供数据,队列满的话会阻塞等待直到start标志位清除
     * 
     * @param element
     * @return
     * @throws Exception
     */
    public boolean offer(T element) throws Exception {
        // 构建数据节点的完整路径
        String nodeFullPath = root.concat("/").concat(Node_NAME);
        try {
            if (queueSize > size()) {
                // 创建持久的节点，写入数据
                zooKeeper.create(nodeFullPath, ObjectToByte(element), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                        CreateMode.PERSISTENT);
                // 再判断一下队列是否满
                if (queueSize > size()) {
                    zooKeeper.delete(startPath, -1); // 确保不存在
                } else {
                    zooKeeper.create(startPath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                }
            } else {
                // 创建队列满的标记
                if (zooKeeper.exists(startPath, false) != null) {
                    zooKeeper.create(startPath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                }

                final CountDownLatch latch = new CountDownLatch(1);
                final Watcher previousListener = new Watcher() {
                    public void process(WatchedEvent event) {
                        if (event.getType() == EventType.NodeDeleted) {
                            latch.countDown();
                        }
                    }
                };

                // 如果节点不存在会出现异常
                zooKeeper.exists(startPath, previousListener);
                latch.await();
                offer(element);

            }
        } catch (ZkNoNodeException e) {
            logger.error("", e);
        } catch (Exception e) {
            throw ExceptionUtil.convertToRuntimeException(e);
        }
        return true;
    }

    /**
     * 从队列取数据,当有start标志位时，开始取数据，全部取完数据后才删除start标志
     * 
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public T poll() throws Exception {

        try {
            // 队列还没满
            if (zooKeeper.exists(startPath, false) == null) {
                final CountDownLatch latch = new CountDownLatch(1);
                final Watcher previousListener = new Watcher() {
                    public void process(WatchedEvent event) {
                        if (event.getType() == EventType.NodeCreated) {
                            latch.countDown();
                        }
                    }
                };

                // 如果节点不存在会出现异常
                zooKeeper.exists(startPath, previousListener);

                // 如果节点不存在会出现异常
                latch.await();
            }

            List<String> list = zooKeeper.getChildren(root, false);
            if (list.size() == 0) {
                return null;
            }
            // 将队列按照由小到大的顺序排序
            Collections.sort(list, new Comparator<String>() {
                public int compare(String lhs, String rhs) {
                    return getNodeNumber(lhs, Node_NAME).compareTo(getNodeNumber(rhs, Node_NAME));
                }
            });

            /**
             * 将队列中的元素做循环，然后构建完整的路径，在通过这个路径去读取数据
             */
            for (String nodeName : list) {
                String nodeFullPath = root.concat("/").concat(nodeName);
                try {
                    T node = (T) ByteToObject(zooKeeper.getData(nodeFullPath, false, null));
                    zooKeeper.delete(nodeFullPath, -1);
                    return node;
                } catch (ZkNoNodeException e) {
                    logger.error("", e);
                }
            }
            return null;
        } catch (Exception e) {
            throw ExceptionUtil.convertToRuntimeException(e);
        }

    }

    /**
     * 截取节点的数字的方法
     * 
     * @param str
     * @param nodeName
     * @return
     */
    private String getNodeNumber(String str, String nodeName) {
        int index = str.lastIndexOf(nodeName);
        if (index >= 0) {
            index += Node_NAME.length();
            return index <= str.length() ? str.substring(index) : "";
        }
        return str;

    }

}

DistributedQueueTest

package zookeeper;

import java.io.Serializable;  

import org.I0Itec.zkclient.ZkClient;  
import org.I0Itec.zkclient.serialize.SerializableSerializer;  

public class DistributedQueueTest {  

   public static void main(String[] args) {  
       ZkClient zkClient = new ZkClient("127.0.0.1:2181", 5000, 5000, new SerializableSerializer());  
       DistributedSimpleQueue<SendObject> queue = new DistributedSimpleQueue<SendObject>(zkClient, "/Queue");  
       new Thread(new ConsumerThread(queue)).start();  
       new Thread(new ProducerThread(queue)).start();  

   }  

}  

class ConsumerThread implements Runnable {  
   private DistributedSimpleQueue<SendObject> queue;  

   public ConsumerThread(DistributedSimpleQueue<SendObject> queue) {  
       this.queue = queue;  
   }  

   public void run() {  
       for (int i = 0; i < 10000; i++) {  
           try {  
               Thread.sleep((int) (Math.random() * 5000));// 随机睡眠一下  
               SendObject sendObject = (SendObject) queue.poll();  
               System.out.println("消费一条消息成功：" + sendObject);  
           } catch (Exception e) {  
           }  
       }  
   }  
}  

class ProducerThread implements Runnable {  

   private DistributedSimpleQueue<SendObject> queue;  

   public ProducerThread(DistributedSimpleQueue<SendObject> queue) {  
       this.queue = queue;  
   }  

   public void run() {  
       for (int i = 0; i < 10000; i++) {  
           try {  
               Thread.sleep((int) (Math.random() * 5000));// 随机睡眠一下  
               SendObject sendObject = new SendObject(String.valueOf(i), "content" + i);  
               queue.offer(sendObject);  
               System.out.println("发送一条消息成功：" + sendObject);  
           } catch (Exception e) {  
           }  
       }  
   }  

}  

class SendObject implements Serializable {  

   private static final long serialVersionUID = 1L;  

   public SendObject(String id, String content) {  
       this.id = id;  
       this.content = content;  
   }  

   private String id;  

   private String content;  

   public String getId() {  
       return id;  
   }  

   public void setId(String id) {  
       this.id = id;  
   }  

   public String getContent() {  
       return content;  
   }  

   public void setContent(String content) {  
       this.content = content;  
   }  

   @Override  
   public String toString() {  
       return "SendObject [id=" + id + ", content=" + content + "]";  
   }  

}

DistributedSimpleQueue

package zookeeper;

import java.util.Collections;  
import java.util.Comparator;  
import java.util.List;  
import org.I0Itec.zkclient.ExceptionUtil;  
import org.I0Itec.zkclient.ZkClient;  
import org.I0Itec.zkclient.exception.ZkNoNodeException;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  


/** 
 * 分布式队列，生产者，消费者的实现 
 * @author linbingwen 
 * 
 * @param <T> 
 */  
public class DistributedSimpleQueue<T> {  

    private static Logger logger = LoggerFactory.getLogger(DistributedSimpleQueue.class);  

    protected final ZkClient zkClient;//用于操作zookeeper集群  
    protected final String root;//代表根节点  

    protected static final String Node_NAME = "n_";//顺序节点的名称  



    public DistributedSimpleQueue(ZkClient zkClient, String root) {  
        this.zkClient = zkClient;  
        this.root = root;  
    }  

    //获取队列的大小  
    public int size() {  
        /** 
         * 通过获取根节点下的子节点列表 
         */  
        return zkClient.getChildren(root).size();  
    }  

    //判断队列是否为空  
    public boolean isEmpty() {  
        return zkClient.getChildren(root).size() == 0;  
    }  

    /** 
     * 向队列提供数据 
     * @param element 
     * @return 
     * @throws Exception 
     */  
    public boolean offer(T element) throws Exception{  

        //构建数据节点的完整路径  
        String nodeFullPath = root .concat( "/" ).concat( Node_NAME );  
        try {  
            //创建持久的节点，写入数据  
            zkClient.createPersistentSequential(nodeFullPath , element);  
        }catch (ZkNoNodeException e) {  
            zkClient.createPersistent(root);  
            offer(element);  
        } catch (Exception e) {  
            throw ExceptionUtil.convertToRuntimeException(e);  
        }  
        return true;  
    }  


    //从队列取数据  
    @SuppressWarnings("unchecked")  
    public T poll() throws Exception {  

        try {  

            List<String> list = zkClient.getChildren(root);  
            if (list.size() == 0) {  
                return null;  
            }  
            //将队列按照由小到大的顺序排序  
            Collections.sort(list, new Comparator<String>() {  
                public int compare(String lhs, String rhs) {  
                    return getNodeNumber(lhs, Node_NAME).compareTo(getNodeNumber(rhs, Node_NAME));  
                }  
            });  

            /** 
             * 将队列中的元素做循环，然后构建完整的路径，在通过这个路径去读取数据 
             */  
            for ( String nodeName : list ){  

                String nodeFullPath = root.concat("/").concat(nodeName);      
                try {  
                    T node = (T) zkClient.readData(nodeFullPath);  
                    zkClient.delete(nodeFullPath);  
                    return node;  
                } catch (ZkNoNodeException e) {  
                    logger.error("",e);  
                }  
            }  

            return null;  

        } catch (Exception e) {  
            throw ExceptionUtil.convertToRuntimeException(e);  
        }  

    }  


    private String getNodeNumber(String str, String nodeName) {  
        int index = str.lastIndexOf(nodeName);  
        if (index >= 0) {  
            index += Node_NAME.length();  
            return index <= str.length() ? str.substring(index) : "";  
        }  
        return str;  

    }  

}

运行结果：

发送一条消息成功：SendObject [id=0, content=content0]
消费一条消息成功：SendObject [id=0, content=content0]
消费一条消息成功：null
发送一条消息成功：SendObject [id=1, content=content1]
消费一条消息成功：SendObject [id=1, content=content1]
发送一条消息成功：SendObject [id=2, content=content2]
消费一条消息成功：SendObject [id=2, content=content2]
发送一条消息成功：SendObject [id=3, content=content3]
发送一条消息成功：SendObject [id=4, content=content4]
消费一条消息成功：SendObject [id=3, content=content3]
消费一条消息成功：SendObject [id=4, content=content4]
发送一条消息成功：SendObject [id=5, content=content5]
消费一条消息成功：SendObject [id=5, content=content5]
消费一条消息成功：null
发送一条消息成功：SendObject [id=6, content=content6]
发送一条消息成功：SendObject [id=7, content=content7]
消费一条消息成功：SendObject [id=6, content=content6]
发送一条消息成功：SendObject [id=8, content=content8]
消费一条消息成功：SendObject [id=7, content=content7]
消费一条消息成功：SendObject [id=8, content=content8]
发送一条消息成功：SendObject [id=9, content=content9]
消费一条消息成功：SendObject [id=9, content=content9]
消费一条消息成功：null
发送一条消息成功：SendObject [id=10, content=content10]
消费一条消息成功：SendObject [id=10, content=content10]

代码来源：
https://blog.csdn.net/evankaka/article/details/70806752

猜你喜欢

转载自blog.csdn.net/xundh/article/details/80192723
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
laravle中orm简单的增删改查
文本分类 特征选取之CHI开方检验
Spark核心编程-WordCount
大数据开发实战系列之电信客服(1)
读书笔记 - 把时间当作朋友 by 李笑来
python 笔记--if else
SpringBoot/Mybatis/Druid, 多数据源MultiDataSource配置思路
排序三个整数
redis集群搭建【2】-Windows中Redis集群搭建
STM32F030驱动TM1650点亮4联数码管
每日归档
更多
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022