curator源码之分布式延迟队列

如果实现一个分布式延迟队列需要考虑哪些方面？至少有这些：数据存在何处、数据以何种格式存储、如何消费、怎样避免重复消费、消费是如何保证顺序、数据在被消费过程中失败了是否会丢失、重试策略……
前段时间想着自己实现个延迟队列，发现curator已经实现，这里就来分析下。

public class DistributedDelayQueueDemo {
    private static CuratorFramework client = CuratorFrameworkFactory.newClient("localhost:2181", new ExponentialBackoffRetry(3000, 2));
    private static String path = "/queue/0001";//队列对应的zk路径
    private static DistributedDelayQueue delayQueue;

    /**
     * 使用静态块启动
     */
    static {
        client.start();
    }

    public static void main(String[] args) throws Exception{
        QueueConsumer consumer = new QueueConsumer() {
            @Override
            public void consumeMessage(String s) throws Exception {
                System.out.println("consume data:"+s+",currentTime:"+System.currentTimeMillis());
            }

            @Override
            public void stateChanged(CuratorFramework curatorFramework, ConnectionState connectionState) {
                System.out.println("state changed");
            }
        };
        delayQueue = QueueBuilder.builder(client, consumer, new QueueSerializer() {
            @Override
            public byte[] serialize(String t) {
                try {
                    return t.getBytes("utf-8");
                }catch (UnsupportedEncodingException e){
                    e.printStackTrace();
                }
                return null;
            }

            @Override
            public String deserialize(byte[] bytes) {
                return new String(bytes);
            }
        },path).buildDelayQueue();
        delayQueue.start();//start方法里新开了子线程去执行完之后会进行回调consumeMessage方法
        System.out.println("delay queue built");
        delayQueue.put("a",System.currentTimeMillis() + 4000);//延迟4s
        delayQueue.put("b",System.currentTimeMillis() + 10000);
        delayQueue.put("c",System.currentTimeMillis() + 100000);
        System.out.println("put ended");
        TimeUnit.MINUTES.sleep(14);
        delayQueue.close();
        TimeUnit.SECONDS.sleep(5);
        client.close();
    }
}

这个是客户端使用的一个例子

private static CuratorFramework client = CuratorFrameworkFactory.newClient("localhost:2181", new ExponentialBackoffRetry(3000, 2));

这一行获取CuratorFramework对象，这里指定了重试策略，后期会专门写文章进行分析。另外需要说明的是这里会实例化ZooKeeper类里的ClientCnxn类，ClientCnxn是ZK客户端的核心类，负责客户端与服务端的通信，它有两个重要的成员(内部类)SendThread(IO读写、心跳检测、断连重试)与EventThread(事件处理：WatchEvent等)。
delayQueue.start()是在进行消费；下面的delayQueue.put()则是在进行数据的存储。
好了，重点看下delayQueue.start()方法，上面的例子使用的是curator-recipes 2.12.0版本，这里源码分析使用的是5.0.0-SNAPSHOT.

public void start() throws Exception
    {
        //使用CAS更新状态，latent:潜在的，隐藏的。这里的state变量没使用static修饰
        if ( !state.compareAndSet(State.LATENT, State.STARTED) )
        {
            throw new IllegalStateException();
        }
        /**
         * 主要节点：
         * PERSISTENT持久节点，节点创建后就一直存在，直到有删除操作来主动清除这个节点，创建该节点的客户端失效也不会消失
         * PERSISTENT_SEQUENTIAL持久顺序节点，此节点特性与上面的一致，额外的是，每个父节点会记录每个子节点的顺序
         * EPHEMERAL临时节点，临时节点的生命周期与客户端会话绑定，客户端失效那这个节点就会被自动清除
         *EPHEMERAL_SEQUENTIAL临时顺序节点，带顺序的临时节点，可用来实现分布式锁
         */
        try
        {
            //创建队列的zk节点，模式为PERSISTENT,使用父容器
            /**
             * 1，使用观察者模式(监听器)
             * 2，使用回调处理队列的子节点信息
             * 3，使用一个版本号对子节点列表时行本地缓存
             *    使用不可变list对子节点列表进行包装
             *    使用版本号跟踪，避免ABA问题
             *    子节点信息使用一个内部类进行封装
             *    最后的forPath指定要操作的ZNode
             *    https://www.jianshu.com/p/998cd2b471ef
             */
            //模式为PERSISTENT
            client.create().creatingParentContainersIfNeeded().forPath(queuePath);//创建一个空节点
        }
        catch ( KeeperException.NodeExistsException ignore )//节点创建失败
        {
            // this is OK
        }
        if ( lockPath != null )
        {
            //根据外部传入参数，决定是否创建对应分布式锁的zk节点
            try
            {
                client.create().creatingParentContainersIfNeeded().forPath(lockPath);
            }
            catch ( KeeperException.NodeExistsException ignore )
            {
                // this is OK
            }
        }

        //如果不是生产者角色，或者设定了有界队列，则启动子节点缓存,isProducerOnly:false
        if ( !isProducerOnly || (maxItems != QueueBuilder.NOT_SET) )
        {
            //底层callback里的path与上面的queuePath值一样
            childrenCache.start();// 这个地方很重要，runLoop里就是从childrenCache里了取的数据
        }

        //如果不是生产者模式，则异步执行runLoop方法,isProducerOnly:false
        if ( !isProducerOnly )
        {
            //这个线程池用来从队列里拉取消息
            service.submit
                (
                    new Callable