Java DelayQueue实现任务延时示例讲解

在项目中有使用到延时队列的场景，做个简单的记录说明；首先DelayQueue实现了BlockingQueue，加入其中的元素必须实现Delayed接口；

当生产者元素调用put往其中加入元素时，出发Delayed接口的compareTo方法进行排序，这个排序是按照时间的，按照计划执行的时间排序，先执行的在前面，后执行的排后面；消费者获取元素时，调用getDelay方法返回的值大于0，则消费者线程wait返回的这个时间后，再从队列头部取出元素；下面是个简单的例子

import org.jetbrains.annotations.NotNull;
import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class DelayEntity implements Delayed {
   private static final Long currentTime = System.currentTimeMillis();
   private String str;
   private Long scheduleTime;
   public DelayEntity(String str, Long delayed) {
       this.str = str;
       scheduleTime = System.currentTimeMillis() + (1000) * delayed;
   }
   @Override
   public long getDelay(@NotNull TimeUnit unit) {
       return unit.convert(scheduleTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
   }
   @Override
   public int compareTo(@NotNull Delayed o) {
       return (int) (this.scheduleTime - ((DelayEntity) o).scheduleTime);
   }
   public String getStr() {
       return str;
   }
   public Long getScheduleTime() {
       return scheduleTime;
   }
   public String showScheduleTime() {
       return "计划执行时间:" + new Date(this.scheduleTime).toString();
   }
}

@Test
   public void test() throws InterruptedException {
       DelayQueue<DelayEntity> delayQueue = new DelayQueue<>();
       delayQueue.put(new DelayEntity("1", 1l));
       delayQueue.put(new DelayEntity("2", 2l));
       delayQueue.put(new DelayEntity("4", 3l));
       while (true) {
           DelayEntity take = delayQueue.take();
           System.out.println("参数:" + take.getStr() + ";计划执行时间:" + take.showScheduleTime() + ";实际执行时间:" + new Date().toString());
       }
   }

下面看下take方法

public E take() throws InterruptedException {
       final ReentrantLock lock = this.lock;
       lock.lockInterruptibly();
       try {
           for (;;) {
               E first = q.peek();
               if (first == null)
                   available.await();
               else {
                   long delay = first.getDelay(NANOSECONDS);
                   if (delay <= 0)
                       return q.poll();
                   first = null; // don't retain ref while waiting
                   if (leader != null)
                       available.await();
                   else {
                       Thread thisThread = Thread.currentThread();
                       leader = thisThread;
                       try {
                           available.awaitNanos(delay);
                       } finally {
                           if (leader == thisThread)
                               leader = null;
                       }
                   }
               }
           }
       } finally {
           if (leader == null && q.peek() != null)
               available.signal();
           lock.unlock();
       }
   }

这里可以看到，他不是一直循环的，是获取到第一个元素的delay等待的时间，之后等待这个时间才去唤醒其他线程；

另外，添加元素时，add方法和put方法都是调用的offer方法，区别是一个返回值，一个没有；

延伸下BlockingQueue的几个常用的操作；

1.offer方法是BlockingQueue的，offer不会阻塞执行的方法，可以添加返回true，否则返回false；

2.BlockingQueue的put方法，如果没有空间，会阻塞一直等到有空间

3.poll获取元素，不会阻塞，获取不到就返回null；

4.take，获取不到就阻塞

来源：https://blog.csdn.net/xiaoguangtouqiang/article/details/124109337