Talking about the use of DelayQueue

First, DelayQueue is an unbounded blocking queue can only be extracted from the elements when its delay has expired. Survival time can be set in the queue, the time element is removed, the unique ID or the like.

DelayQueue blocking queue is also often used in our system development, such as: How long delay to perform an operation; task scheduling system that can accurately grasp the execution time of the task. In order to have invoked behavior, into the elements DelayDeque must inherit Delayed interface. Delayed delay interfaces make an object object so that the object is stored in DelayQueue class having the activation date.

• CompareTo (Delayed o): Delayed interface inherits the Comparable interface, so with this method.
• getDelay (TimeUnit unit): This method returns the time remaining to activation date, time unit specified by the unit parameter.
• new DelayedItem (T t, Long liveTime, String id) - Constructor, after the code is attached.

public class DelayEvent<T extends Runnable> implements Delayed {

    private T t;
    private Long liveTime ;
    private Long removeTime;
    private String id;
    private static final AtomicLong atomic = new AtomicLong(0);


    public DelayEvent(T t,Long liveTime, String id){
        this.setT(t);
        this.liveTime = liveTime;
        this.id = id;
        this.removeTime = removeTime ;
    }

    @Override
    public int compareTo(Delayed o) {
        if (o == null) return 1;
        if (o == this) return  0;
        if (o instanceof DelayEvent){
            DelayEvent<T> tmpDelayEvent = (DelayEvent<T>)o;
            if (removeTime > tmpDelayEvent.removeTime ) {
                return 1;
            }else if (removeTime.equals(tmpDelayEvent.removeTime)) {
                return 0;
            }else {
                return -1;
            }
        }
        long diff = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return diff > 0 ? 1:diff == 0? 0:-1;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(removeTime - System.nanoTime(), unit);
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    @Override
    public int hashCode(){
        return id.hashCode();
    }

    @Override
    public boolean equals(Object object){
        if (object instanceof DelayEvent) {
            DelayedItem o = (DelayEvent) object;
            return id != null && o.id != null && id.equals(o.id);
        }
        return false;
    }

    public Long getLiveTime() {
        return liveTime;
    }

    public Long getRemoveTime() {
        return removeTime;
    }

    public String getId() {
        return id;
    }

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

　　Operation timing queue (queue timer is added, removed timer queues, etc.):

interface TimeQueue public <T the extends the Runnable> { 


    / ** 
     * Add new timing queue 
     * @param delayedEvent 
     * @return 
     * / 
    Boolean addQueue (DelayedEvent <T> delayedEvent); 

    / ** 
     * rejoin timer queue 
     * @param delayedEvent 
     * @ return 
     * / 
    Boolean reAddQueue (delayedEvent <T> delayedEvent); 

    / ** 
     * delete timer queue 
     * @param delayedEvent 
     * @return 
     * / 
    Boolean removeQueue (delayedEvent <T> delayedEvent); 

    / ** 
     * contains 
     * @param delayedEvent  
     * @return 
     * /
    Boolean the contains (delayedEvent <T> delayedEvent); 

    int size ();
}

　　Interface implementation class:

@Component
public class TimeQueueImpl<T extends Runnable> implements TimeQueue<T> {

    public static final DelayQueue<DelayedEvent> timeQueue = new DelayQueue<DelayedEvent>();


    @Override
    public boolean reAddQueue(DelayedEvent<T> delayedEvent) {
        removeQueue(delayedEvent);
        return addQueue(delayedEvent);
    }

    @Override
    public boolean addQueue(DelayedEvent<T> delayedEvent) {
        boolean addFlag = timeQueue.add(delayedEvent);
        return addFlag;
    }

    @Override
    public boolean removeQueue(DelayedEvent<T> delayedEvent) {
        boolean removeFlag = timeQueue.remove(delayedEvent);
        return removeFlag;
    }

    @Override
    public boolean contains(DelayedEvent<T> delayedEvent) {
        return timeQueue.contains(delayedItem);
    }

    @Override
    public int size() {
        return timeQueue.size();
    }
}

　　Operation Case Code:

timeQueue.addQueue (new DelayedEvent (new delayQueueTask ( " used herein resources need to pass"), "to be triggered period", "unique queue ID"); 
// specific implementation: 
public class DelayQueueTask the implements Runnable { 

    Private AService the AService; 

    public DelayQueueTask (the AService AService) { 
        this.aService = AService; 
    } 

    @Override 
    public void RUN () { 
        the try { 
            aService.execute (); 
        } the catch (exception E) { 
            log.error ( "exception processing task: { } "," Exception == ", E); 
        } 
    } 
}