Class DistributedDelayQueue<T>

  • All Implemented Interfaces:
    java.io.Closeable, java.lang.AutoCloseable, QueueBase<T>

    public class DistributedDelayQueue<T>
    extends java.lang.Object
    implements java.io.Closeable, QueueBase<T>

    A variation of the DistributedPriorityQueue that uses time as the priority. When items are added to the queue, a delay value is given. The item will not be sent to a consumer until the time elapses.

    • Method Detail

      • start

        public void start()
                   throws java.lang.Exception
        Start the queue. No other methods work until this is called
        Specified by:
        start in interface QueueBase<T>
        Throws:
        java.lang.Exception - startup errors
      • close

        public void close()
                   throws java.io.IOException
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface java.io.Closeable
        Throws:
        java.io.IOException
      • put

        public void put​(T item,
                        long delayUntilEpoch)
                 throws java.lang.Exception
        Add an item into the queue. Adding is done in the background - thus, this method will return quickly.

        NOTE: if an upper bound was set via QueueBuilder.maxItems, this method will block until there is available space in the queue.
        Parameters:
        item - item to add
        delayUntilEpoch - future epoch (milliseconds) when this item will be available to consumers
        Throws:
        java.lang.Exception - connection issues
      • put

        public boolean put​(T item,
                           long delayUntilEpoch,
                           int maxWait,
                           java.util.concurrent.TimeUnit unit)
                    throws java.lang.Exception
        Same as put(Object, long) but allows a maximum wait time if an upper bound was set via QueueBuilder.maxItems.
        Parameters:
        item - item to add
        delayUntilEpoch - future epoch (milliseconds) when this item will be available to consumers
        maxWait - maximum wait
        unit - wait unit
        Returns:
        true if items was added, false if timed out
        Throws:
        java.lang.Exception
      • putMulti

        public void putMulti​(MultiItem<T> items,
                             long delayUntilEpoch)
                      throws java.lang.Exception
        Add a set of items with the same priority into the queue. Adding is done in the background - thus, this method will return quickly.

        NOTE: if an upper bound was set via QueueBuilder.maxItems, this method will block until there is available space in the queue.
        Parameters:
        items - items to add
        delayUntilEpoch - future epoch (milliseconds) when this item will be available to consumers
        Throws:
        java.lang.Exception - connection issues
      • putMulti

        public boolean putMulti​(MultiItem<T> items,
                                long delayUntilEpoch,
                                int maxWait,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.Exception
        Same as putMulti(MultiItem, long) but allows a maximum wait time if an upper bound was set via QueueBuilder.maxItems.
        Parameters:
        items - items to add
        delayUntilEpoch - future epoch (milliseconds) when this item will be available to consumers
        maxWait - maximum wait
        unit - wait unit
        Returns:
        true if items was added, false if timed out
        Throws:
        java.lang.Exception
      • flushPuts

        public boolean flushPuts​(long waitTime,
                                 java.util.concurrent.TimeUnit timeUnit)
                          throws java.lang.InterruptedException
        Description copied from interface: QueueBase
        Wait until any pending puts are committed
        Specified by:
        flushPuts in interface QueueBase<T>
        Parameters:
        waitTime - max wait time
        timeUnit - time unit
        Returns:
        true if the flush was successful, false if it timed out first
        Throws:
        java.lang.InterruptedException - if thread was interrupted
      • getPutListenerContainer

        public org.apache.curator.framework.listen.ListenerContainer<QueuePutListener<T>> getPutListenerContainer()
        Return the manager for put listeners
        Specified by:
        getPutListenerContainer in interface QueueBase<T>
        Returns:
        put listener container
      • getLastMessageCount

        public int getLastMessageCount()
        Return the most recent message count from the queue. This is useful for debugging/information purposes only.
        Specified by:
        getLastMessageCount in interface QueueBase<T>
        Returns:
        count (can be 0)