DelayQueue分析

1.DelayQueue基本简介:

   DelayQueue是BlockingQueue的一种,不同的是DelayQueue中的元素都有delay time(延迟时间),只有delay time过期,元素才可以被出队列。DelayQueue的内部是由一个PriorityQueue(优先队列)来实现,优先因素是delay time,也就是说队头元素是delay time最短的元素。当队列是空或队列中没有过期时间，则poll操作放回null。当getDelay方法返回值等于0或小于0时,该元素就是过期,可以出队列。

2.实现细节:

1. 字段:

 private final transient ReentrantLock lock = new ReentrantLock();//锁,用于同步阻塞
    private final PriorityQueue<E> q = new PriorityQueue<E>();//优先队列,用于存储队列元素
    private Thread leader = null;//主线程,这个字段就比较重要了,可以说是整个DelayQueue的核心了。这个字段存储着等待队头元素过期的线程。其他线程会在poll和take方法被await(),当主线程从poll和take方法返回,会唤醒一个线程,这个线程将成为主线程。当往队列添加一个元素时，会使主线程失效，这时会唤醒一个线程，它成为主线程。

2.API实现细节:

   

• 插入元素:add(E e), offer(E e),put(E e);
     add(E e),put(E e)操作实际上只调用了offer(E e);
     还有一个Api,offer(E e, long timeout, TimeUnit unit),这个插入API有超时限制。但是，插入操作是一个非阻塞操作,所以timeout实际上会被忽略,其内部也是直接调用offer(E e)

    //当插入一个元素的延迟时间比队列中所有元素的时间都要早,使主线程无效,并唤醒线程
    public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            q.offer(e);
            if (q.peek() == e) {
                leader = null;
                available.signal();//使主线程无效
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

• 取出元素:poll(),take()

    //这是一个非阻塞的方法,当队头元素不为空并且已经过期,将队头元素出队列,否则立即返回,不会阻塞等待队头过期。
    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            E first = q.peek();
            if (first == null || first.getDelay(NANOSECONDS) > 0)
                return null;
            else
                return q.poll();
        } finally {
            lock.unlock();
        }
    }




//该方法与poll()的区别是:take()会阻塞等待队头元素过期
public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                E first = q.peek();
                if (first == null)
                    available.await(); //队列为空,所有线程await()
                else {
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        return q.poll();//元素时间到期,出队列
                    /*
                     * 想想假设现在延迟队列里面有三个对象。

                     * 线程A进来获取first,然后进入 else 的else ,设置了leader为当前线程A
                     *线程B进来获取first,进入else的阻塞操作,然后无限期等待
                     *这时在JDK 1.7下面他是持有first引用的
                     *如果线程A阻塞完毕,获取对象成功,出队,这个对象理应被GC回收,但是他还被线程B持有着,GC链可达,所以不能回收这个first.
                     *假设还有线程C 、D、E.. 持有对象1引用,那么无限期的不能回收该对象1引用了,那么就会造成内存泄露.
                     *
                     *
                     *
                     * **/
                    first = null; // don't retain ref while waiting
                    if (leader != null)
                        available.await();//如果已经有线程在take元素,该线程进入await
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;                //没有线程取元素,将leader线程设为当前线程
                        try {
                            available.awaitNanos(delay);   //等待delay后醒来
                        } finally {
                            if (leader == thisThread)
                                leader = null;                  //醒来之后将leader线程置空
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();         //唤醒所有线程
            lock.unlock();
        }
    }