Java8 LinkedBlockingQueue和DelayQueue 源码解析

最新推荐文章于 2023-06-17 09:34:53 发布

孙大圣666

最新推荐文章于 2023-06-17 09:34:53 发布

阅读量634

点赞数 1

分类专栏： java8并发工具类源码解析文章标签： BlockingQueue DelayQueue

本文链接：https://blog.csdn.net/qq_31865983/article/details/105390529

版权

java8并发工具类源码解析专栏收录该内容

35 篇文章 63 订阅

订阅专栏

一、LinkedBlockingQueue

5、remove / clear / drainTo

6、iterator / Itr

7、跟ArrayBlockingQueue的实现差异总结

5、remove / clear /drainTo

6、iterator / Itr

LinkedBlockingQueue表示一个基于链表实现的可选的固定容量的，先进先出的，线程安全的队列（栈），其接口的语义和ArrayBlockingQueue基本一致；DelayQueue 表示一个基于PriorityQueue优先级队列实现的无固定容量的，先进先出的，线程安全的队列，跟ArrayBlockingQueue相比，获取元素时增加了有效期判断，如果已过期则返回，否则返回null或者阻塞等待其过期。本篇博客就来详细探讨这两个类的实现细节。

一、LinkedBlockingQueue

1、定义

该类的类继承关系跟ArrayBlockingQueue是一样，两者的差异主要是实现机制不同，如下：

LinkedBlockingQueue是基于链表的，内部类Node用来描述链表中的一个节点，其定义如下：

该类包含的属性如下：

    /** 队列的容量 */
    private final int capacity;

    /**队列中元素的个数 */
    private final AtomicInteger count = new AtomicInteger();

    /**链表头*/
    transient Node<E> head;

    /**链表尾*/
    private transient Node<E> last;

    /** 取出元素时获取的锁 */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** 队列是空时的等待条件 */
    private final Condition notEmpty = takeLock.newCondition();

    /** 插入元素时获取的锁 */
    private final ReentrantLock putLock = new ReentrantLock();

    /** 队列是满的等待条件*/
    private final Condition notFull = putLock.newCondition();

因为跟ArrayBlockingQueue实现的接口是一样的，所以各方法的用途和接口逻辑是基本一样的，下面重点分析两者间的实现上的差异。

2、构造方法

 //不限定容量的，默认容量就是int的最大值
 public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

//限定容量
public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        //初始化时head节点
        last = head = new Node<E>(null);
    }

public LinkedBlockingQueue(Collection<? extends E> c) {
        this(Integer.MAX_VALUE);
        final ReentrantLock putLock = this.putLock;
        putLock.lock(); //加锁的目的主要是为了保证修改对其他CPU立即可见
        try {
            int n = 0;
            //遍历集合c，将里面的元素加入到队列中
            for (E e : c) {
                if (e == null)
                    throw new NullPointerException();
                if (n == capacity)
                    throw new IllegalStateException("Queue full");
                //加入到队列中    
                enqueue(new Node<E>(e));
                ++n;
            }
            count.set(n);
        } finally {
            putLock.unlock();
        }
    }

3、put / offer

public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        //此处使用AtomicInteger，避免因为获取锁导致等待
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false;
        int c = -1;
        //创建一个新节点
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            if (count.get() < capacity) {
                //加入到队列中
                enqueue(node);
                //增加元素个数
                c = count.getAndIncrement();
                if (c + 1 < capacity)
                    //队列中还有可用容量，唤醒因为队列满了而阻塞的线程
                    //ArrayBlockingQueue中插入元素和获取元素是同一个锁，从队列中取出一个元素时会唤醒因为队列满而等待的线程
                    //LinkedBlockingQueue是两个锁，从队列中取出元素 
                    notFull.signal();
            }
        } finally {
            putLock.unlock();
        }
        //c是插入之前的元素个数，只有个数是0的情况下才可能存在因为队列是空的而阻塞的线程
        if (c == 0)
            //唤醒因为队列是空的而等待的线程
            signalNotEmpty();
        return c >= 0;
    }

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

        if (e == null) throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        int c = -1;
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        //如果被中断了抛出异常
        putLock.lockInterruptibly();
        try {
            //队列满了，循环等待，直到列队有可用容量或者等待超时了
            while (count.get() == capacity) {
                if (nanos <= 0)
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(new Node<E>(e));
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                //队列中还有可用容量，唤醒因为队列满了而阻塞的线程
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return true;
    }

public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        int c = -1;
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
            //队列满了，循环等待，直到列队有可用容量
            while (count.get() == capacity) {
                notFull.await();
            }
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
    }

//插入到链表的后面
private void enqueue(Node<E> node) {
        last = last.next = node;
    }

private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            //唤醒因为队列是空的而等待的线程
            notEmpty.signal();
        } finally {
            takeLock.unlock();
        }
    }

4、peek / poll /take

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        //队列为空则循环等待
        while (count.get() == 0) {
            notEmpty.await();
        }
        //获取并移除链表头
        x = dequeue();
        //元素个数减1，返回减1前的值
        c = count.getAndDecrement();
        if (c > 1)
            //唤醒因为队列是空的而阻塞的线程，c大于1，这次take移除了1个，还剩至少1个
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        //唤醒因为队列是满的而等待的线程
        signalNotFull();
    return x;
} 

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    E x = null;
    int c = -1;
    long nanos = unit.toNanos(timeout);
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        //队列为空则循环等待，如果超时则返回null
        while (count.get() == 0) {
            if (nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        x = dequeue();
        c = count.getAndDecrement();
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
} 

public E poll() {
    final AtomicInteger count = this.count;
    //为空直接返回null
    if (count.get() == 0)
        return null;
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        if (count.get() > 0) {
            x = dequeue();
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();
        }
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();
    return x;
} 

public E peek() {
    if (count.get() == 0)
        return null;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        //为空直接返回null，不用等待
        Node<E> first = head.next;
        if (first == null)
            return null;
        else
            return first.item;
    } finally {
        takeLock.unlock();
    }
}

private E dequeue() {
        //获取并移除链表头
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // help GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }

//唤醒因为队列是满的而等待的线程
 private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();
        } finally {
            putLock.unlock();
        }
    }

5、remove / clear / drainTo

public boolean remove(Object o) {
        if (o == null) return false;
        //需要同时获取两个锁，因为移除的时候可能是移除链表尾部的节点也可能是链表中间的节点
        //前者需要获取takeLock，后者必须获取putLock，因为需要修改链表关系
        fullyLock();
        try {
            //从head往后遍历，p表示当前节点，trail表示该节点的前一个节点
            for (Node<E> trail = head, p = trail.next;
                 p != null;
                 trail = p, p = p.next) {
                if (o.equals(p.item)) {
                    //如果找到目标节点，将其从链表中移除
                    unlink(p, trail);
                    return true;
                }
            }
            return false;
        } finally {
            //释放两个锁
            fullyUnlock();
        }
    }

public void clear() {
        fullyLock();
        try {
            //遍历整个链表，将各节点的链表关系和item属性都去除
            for (Node<E> p, h = head; (p = h.next) != null; h = p) {
                h.next = h;
                p.item = null;
            }
            head = last;
            if (count.getAndSet(0) == capacity)
                //如果修改前容量是满的，则唤醒因为队列是满的而阻塞的线程
                notFull.signal();
        } finally {
            fullyUnlock();
        }
    }

public int drainTo(Collection<? super E> c) {
        return drainTo(c, Integer.MAX_VALUE);
    }

public int drainTo(Collection<? super E> c, int maxElements) {
        //校验参数合法性
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        boolean signalNotFull = false;
        //因为是取的链表头，所以需要获取两个锁，只需要一个takeLock即可
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();
        try {
            //取maxElements和元素个数的最小值
            int n = Math.min(maxElements, count.get());
            // count.get provides visibility to first n Nodes
            Node<E> h = head;
            int i = 0;
            try {
                //从head开始往后遍历，取n个元素，head是最早插入的
                while (i < n) {
                    Node<E> p = h.next;
                    //将链表节点保存的元素引用放入集合中
                    c.add(p.item);
                    //链表引用关系清除
                    p.item = null;
                    h.next = h;
                    h = p;
                    ++i;
                }
                return n;
            } finally {
                //n大于0，此处i肯定大于0，因为获取锁takeLock后，就只有当前线程可以移除节点
                if (i > 0) {
                    //重置head
                    head = h;
                    //如果取出元素前队列是满的，则唤醒因为队列满的而等待的线程
                    signalNotFull = (count.getAndAdd(-i) == capacity);
                }
            }
        } finally {
            takeLock.unlock();
            if (signalNotFull)
                signalNotFull();
        }
    }

void fullyLock() {
        putLock.lock();
        takeLock.lock();
    }

void fullyUnlock() {
        takeLock.unlock();
        putLock.unlock();
    }

void unlink(Node<E> p, Node<E> trail) {
        //将p从链表中移除
        p.item = null;
        trail.next = p.next;
        if (last == p)
            //如果p是最后一个节点，将trail作为last
            last = trail;
        if (count.getAndDecrement() == capacity)
            //如果移除前链表是满的，则唤醒因为队列满了而等待的线程
            notFull.signal();
    }

6、iterator / Itr

iterator返回一个遍历器实例，如下：

public Iterator<E> iterator() {
        return new Itr();
    }

private class Itr implements Iterator<E> {
        //next方法返回的节点
        private Node<E> current;
        //上一次next方法返回的节点
        private Node<E> lastRet;
        //next方法返回的元素
        private E currentElement;

        Itr() {
            fullyLock();
            try {
                //因为head节点初始化时是一个空的Node节点，所以遍历的第一个节点是head的next节点
                current = head.next;
                if (current != null)
                    currentElement = current.item;
            } finally {
                fullyUnlock();
            }
        }

        public boolean hasNext() {
            return current != null;
        }

        private Node<E> nextNode(Node<E> p) {
            for (;;) {
                Node<E> s = p.next;
                if (s == p)
                    //s等于p说明这是一个无效节点，返回链表头的有效节点
                    return head.next;
                //s等于null，p是最后一个节点    
                if (s == null || s.item != null)
                    return s;
                //如果s不等于null但是item为null，则进入下一个节点
                //此时通常s等于p了    
                p = s;
            }
        }

        public E next() {
            //获取两个锁
            fullyLock();
            try {
                if (current == null)
                    throw new NoSuchElementException();
                E x = currentElement;
                //保存上一次的
                lastRet = current;
                //获取下一个节点
                current = nextNode(current);
                //获取下一个返回的元素
                currentElement = (current == null) ? null : current.item;
                return x;
            } finally {
                fullyUnlock();
            }
        }

        public void remove() {
            if (lastRet == null)
                throw new IllegalStateException();
            fullyLock();
            try {
                Node<E> node = lastRet;
                lastRet = null;
                //从head开始往后遍历
                for (Node<E> trail = head, p = trail.next;
                     p != null;
                     trail = p, p = p.next) {
                    if (p == node) {
                        //找到目标节点并移除
                        unlink(p, trail);
                        break;
                    }
                }
            } finally {
                fullyUnlock();
            }
        }
    }

7、跟ArrayBlockingQueue的实现差异总结

主要有以下几点：

ArrayBlockingQueue是基于循环数组实现的，容量是固定的，循环数组是指插入或者移除元素到达数组末尾时又会从头开始；LinkedBlockingQueue 是基于单向链表的，如果指定容量就是固定容量，如果没有指定，则容量默认是int的最大值。
ArrayBlockingQueue中维护元素的个数的属性是一个普通的int类型，读取和修改该属性必须获取锁；LinkedBlockingQueue中是一个AtomicInteger类型，这样在判断队列是否为空时就不需要加锁了，可以快速返回，避免因为获取锁而等待。
ArrayBlockingQueue中插入元素和移除元素时都需要获取同一个锁，即这两个动作不能同时进行，这是因为移除元素时，移除元素的索引takeIndex不能超过插入元素的索引putIndex，如果等于就表示队列中元素已经都空了；LinkedBlockingQueue中插入元素和从链表头移除元素是两把锁，putLock和takeLock，这样可以让两个操作同时进行效率，效率更高；之所以能使用两把锁，这是因为往链表中插入元素是插入到链表尾，而移除元素是移除链表头的元素，两个是互相独立的。但是执行clear和remove方法，执行Itr的next和remove方法时必须同时获取两把锁，这是因为这种场景下不允许队列发生修改。
ArrayBlockingQueue中通过内部类Itr执行遍历时不需要上锁，ArrayBlockingQueue执行特定操作时会通过负责跟踪Itr的Itrs的回调方法，通过Itr比如某个对象被删除了，然后Itr会重新调整自己下一个遍历的元素，整体逻辑比较复杂；LinkedBlockingQueue的实现比较简单，执行next和remove方法时要获取两个锁，就避免了再遍历时链表发生改变了，实现相对简单明了。
ArrayBlockingQueue每插入一个元素后都需要调用signal方法唤醒因为队列是空的而阻塞的线程，即使此时没有等待的线程；LinkedBlockingQueue会校验插入元素前的队列容量，如果插入前的队列容量是0，那么有可能有线程因为队列是空的而阻塞，才会调用signal方法，减少不必要的调用。
ArrayBlockingQueue每移除一个元素后都需要调用signal方法唤醒因为队列是满的而阻塞的线程，即使此时没有等待的线程；LinkedBlockingQueue会校验移除元素前队列的容量，如果队列是满的，才有可能存在因为队列是满的而阻塞的线程，才会调用signal方法唤醒阻塞的线程，减少不必要的调用。
ArrayBlockingQueue执行clear或者drainTo方法时，移除了指定数量的元素，就会通过for循环调用该数量次的signal方法，唤醒因为线程满了而阻塞的线程，不能超过该数量且在Condition上有等待的线程。之所以不能超过该数量，是为了避免唤醒过多的线程，他们会因为队列满了而再次阻塞。LinkedBlockingQueue判断移除前队列的数量是满的，则通过signal方法唤醒因为队列是满的而阻塞的线程，但是只调用一次，因为队列是满的线程被唤醒后，会尝试插入到队列中，如果插入成功后还有多余的容量，则会尝试唤醒下一个因为队列是满的而阻塞的线程，从而巧妙的避免了线程被唤醒后因为队列是满的而再次阻塞的问题。
LinkedBlockingQueue在移除元素时，如果移除前队列容量大于1，会唤醒因为队列是空的而阻塞的线程，这是因为LinkedBlockingQueue下元素插入时，只有队列原来是空才会唤醒因为队列是空的而阻塞的线程，即如果有多个阻塞的线程，这种情形下只会唤醒一个。这时已经被唤醒的线程会判断队列中是否有多余的元素，如果有则继续唤醒下一个阻塞的线程，如此将所有阻塞的线程都唤醒。ArrayBlockingQueue下因为每次插入时都要唤醒一次因为队列是空而阻塞的线程，就不存在上述问题了。

二、DelayQueue

1、定义

DelayQueue的类继承关系如下：

其中Delayed接口并不是DelayQueue直接实现的，而是加入到DelayQueue中的元素实现的接口，其定义如下：

其中Comparable接口主要用于排序使用，getDelay方法用于判断这个元素是否过期，即是否满足指定的延迟时间，返回0或者-1表示已过期，返回一个正值表示剩余的有效期，入参unit就是为了将剩余的有效期转换成unit指定的单位，DelayQueue使用的是纳秒。

DelayQueue包含的属性如下：

//同步的锁
private final transient ReentrantLock lock = new ReentrantLock();

//实际保存队列元素的优先级队列
private final PriorityQueue<E> q = new PriorityQueue<E>();

//记录第一个等待获取已过期元素的线程，leader线程阻塞时可以根据链表头元素的剩余有效期设置等待超时时间，避免无期限等待，其他非leader线程在没有设置等待超时的情形下因为无法预知链表元素的有效期只能无期限等待，等待leader线程被唤醒获取链表头元素后，就唤醒下一个等待的线程，然后按照相同的方式同样设置等待超时时间
private Thread leader = null;

//没有已过期的元素，则在此Condition上等待
private final Condition available = lock.newCondition();

2、使用

DelayQueue主要适用于缓存系统，调度系统等对时间比较敏感的系统实现中，测试用例如下：

class CacheData<T> implements Delayed {
    private T data;

    private long deadline;

    public CacheData(T data, int cacheTime) {
        this.data = data;
        this.deadline=System.currentTimeMillis()+cacheTime;
    }

    public T getData() {
        return data;
    }

    @Override
    public int compareTo(Delayed o) {
        long result = this.getDelay(TimeUnit.NANOSECONDS)
                - o.getDelay(TimeUnit.NANOSECONDS);
        if (result < 0) {
            return -1;
        } else if (result > 0) {
            return 1;
        } else {
            return 0;
        }
    }
    @Override
    public long getDelay(TimeUnit unit) {
        //计算剩余有效期
        long diff = deadline-System.currentTimeMillis();
        if(diff>0) {
            //转换成指定的单位
            return unit.convert(diff, TimeUnit.MILLISECONDS);
        }
        return diff;
    }
}

public class DelayQueueTest {
    @Test
    public void test() throws Exception {
        CacheData<String> a=new CacheData<>("a",1000);
        CacheData<String> a2=new CacheData<>("b",2000);
        CacheData<String> a3=new CacheData<>("c",3000);
        CacheData<String> a4=new CacheData<>("d",4000);
        CacheData<String> a5=new CacheData<>("e",5000);
        DelayQueue<CacheData> delayQueue=new DelayQueue<>();
        delayQueue.add(a);
        delayQueue.add(a2);
        delayQueue.add(a3);
        delayQueue.add(a4);
        delayQueue.add(a5);
        CountDownLatch countDownLatch=new CountDownLatch(delayQueue.size());
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                try {
                    long start=System.currentTimeMillis();
                    CacheData<String> cacheData=delayQueue.take();
                    System.out.println("get data->"+cacheData.getData()+",time->"+(System.currentTimeMillis()-start));
                    countDownLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        for(int i=0;i<5;i++){
            new Thread(runnable).start();
        }
        countDownLatch.await();
        System.out.println("main end");
    }
}

其运行结果如下：

//线程阻塞等待的时间跟这条记录的有效期的时间基本一致
get data->a,time->996
get data->b,time->1995
get data->c,time->2995
get data->d,time->3994
get data->e,time->4993
main end

3、add / offer / put

这里并不是严格按照BlockingQueue接口的语义来实现方法的，都是利用不带时间参数的offer方法来实现的

 public boolean add(E e) {
        return offer(e);
    }

public void put(E e) {
        offer(e);
    }

public boolean offer(E e, long timeout, TimeUnit unit) {
        return offer(e);
    }

public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //加入到优先级队列中
            q.offer(e);
            if (q.peek() == e) {
                //等于e，说明该队列原来是空的
                leader = null;
                //唤醒等待的线程
                available.signal();
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

4、poll / take / peek

这几个方法的实现符合BlockingQueue接口的语义，跟ArrayBlockingQueue一致，区别在于返回元素前需要检查元素是否过期了，如果未过期则返回null，否则会移除并返回队列头元素。

//peek返回队列头元素，不移除
public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.peek();
        } finally {
            lock.unlock();
        }
    }

public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取队列头元素
            E first = q.peek();
            //如果为空或者未过期则返回null
            if (first == null || first.getDelay(NANOSECONDS) > 0)
                return null;
            else
                //不为空且已过期，则返回并移除
                return q.poll();
        } finally {
            lock.unlock();
        }
    }

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                E first = q.peek();
                if (first == null) {
                    //如果队列为空则循环等待
                    if (nanos <= 0)
                        //等待超时返回null
                        return null;
                    else
                        nanos = available.awaitNanos(nanos);
                } else {
                    //队列不为空，delay表示剩余的有效期
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0) //已过期
                        return q.poll();
                    if (nanos <= 0) //未过期，等待超时
                        return null;
                    first = null; // don't retain ref while waiting
                    if (nanos < delay || leader != null)
                        //如果等待的时间小于有效期或者leader不为空，则等待指定时间
                        nanos = available.awaitNanos(nanos);
                    else {
                        //如果等待时间大于有效期，则等待有效期
                        Thread thisThread = Thread.currentThread();
                        //记录等待的线程
                        leader = thisThread;
                        try {
                            //等待指定时间，返回已经等待的时间
                            //调用awaitNanos后会释放锁，这时其他的调用poll方法并获取锁的线程就会发现leader非空了，然后按照最长的时间来等待
                            long timeLeft = available.awaitNanos(delay);
                            nanos -= delay - timeLeft;
                        } finally {
                            //被唤醒后将leader重置为null
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            //leader线程被唤醒后会将leader置为null，如果还有节点，则唤醒下一个等待的线程
            if (leader == null && q.peek() != null)
                available.signal(); //唤醒等待的线程
            lock.unlock();
        }
    }

//逻辑同上，就是无法指定等待的时间
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)
                        //无期限等待，直到被leader线程唤醒
                        available.await();
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            //释放锁后，其他进入此方法的线程后，leader属性就不为空了
                            available.awaitNanos(delay);
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            //leader线程被唤醒后会将leader置为null，如果还有节点，则唤醒下一个等待的线程
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }

5、remove / clear /drainTo

remove和clear方法都是直接使用PriorityQueue的方法，drainTo方法从队列中移除元素时，会判断元素是否过期，如果已过期则添加到集合中，否则终止遍历，返回已添加到集合中的元素个数

public boolean remove(Object o) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //移除某个元素
            return q.remove(o);
        } finally {
            lock.unlock();
        }
    }

public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //清空队列
            q.clear();
        } finally {
            lock.unlock();
        }
    }

//返回已添加到集合中的元素个数
public int drainTo(Collection<? super E> c) {
        //校验参数合法性
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            int n = 0;
            //将已过期的元素从队列中移除加入到集合c中
            for (E e; (e = peekExpired()) != null;) {
                c.add(e);       // In this order, in case add() throws.
                q.poll();
                ++n;
            }
            return n;
        } finally {
            lock.unlock();
        }
    }

public int drainTo(Collection<? super E> c, int maxElements) {
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            int n = 0;
            for (E e; n < maxElements && (e = peekExpired()) != null;) {
                c.add(e);       // In this order, in case add() throws.
                q.poll();
                ++n;
            }
            return n;
        } finally {
            lock.unlock();
        }
    }

private E peekExpired() {
        //判断链表头元素是否已过期，如果未过期返回null
        E first = q.peek();
        return (first == null || first.getDelay(NANOSECONDS) > 0) ?
            null : first;
    }

6、iterator / Itr

元素的遍历是基于当前队列的快照，即遍历过程中无法感知到队列的修改；元素遍历过程中被移除了，底层是通过PriorityQueue的迭代器来移除的。

public Iterator<E> iterator() {
        //遍历的是当前队列的一个快照，即遍历的过程中无法感知队列的修改
        return new Itr(toArray());
    }

private class Itr implements Iterator<E> {
        //保存队列元素的数组
        final Object[] array; // Array of all elements
        //下一个返回的元素的索引
        int cursor;           // index of next element to return
        //上一次返回的元素的索引
        int lastRet;          // index of last element, or -1 if no such

        Itr(Object[] array) {
            //cursor的初始值就是0
            lastRet = -1;
            this.array = array;
        }

        public boolean hasNext() {
            return cursor < array.length;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (cursor >= array.length)
                throw new NoSuchElementException();
            lastRet = cursor;
            //返回cursor当前值对应的数组元素，然后再将其加1
            return (E)array[cursor++];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            //移除lastRet对应的元素    
            removeEQ(array[lastRet]);
            lastRet = -1;
        }
    }

void removeEQ(Object o) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //遍历PriorityQueue，将其从队列中移除
            for (Iterator<E> it = q.iterator(); it.hasNext(); ) {
                if (o == it.next()) {
                    //找到目标 元素
                    it.remove();
                    break;
                }
            }
        } finally {
            lock.unlock();
        }
    }


public Object[] toArray() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return q.toArray();
        } finally {
            lock.unlock();
        }
    }

孙大圣666

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java8 LinkedBlockingQueue和DelayQueue 源码解析

目录一、LinkedBlockingQueue1、定义2、构造方法3、put /offer4、peek /poll /take5、remove /clear /drainTo6、iterator /Itr7、跟ArrayBlockingQueue的实现差异总结二、DelayQueue1、定义2、使用3、add / offe...
复制链接

扫一扫