Queue和BlockingQueue的使用以及使用BlockingQueue实现生产者-消费者
Java提供了两种新的容器类型:Queue和BlockingQueue。
Queue用于保存一组等待处理的元素。它提供了几种实现，包括:ConcurrentLinkedQueue,这是一个先进先出的并发对列，以及PriorityQueue，这是一个非并发的优先队列。Queue上的操作不会阻塞，如果队列为空，获取元素的操作将返回空值。虽然可以用List来模拟一个Queue的行为----事实上正是通过LinkedList来实现Queue的行为的，但还需要一个Queue的类，因为它能去掉List的随机访问需求，从而实现更高效的并发。
BlockingQueue扩展了Queue，增加了可阻塞的插入和获取操作。如果队列为空那么获取元素的操作将会一直阻塞，直到队列出现一个可以可用的元素。如果队列已满(对于有界队列来说)，那么插入元素的操作将一直阻塞，直到队列中出现可用的元素。在"生产者-消费者"设计模式中，阻塞队还是非常有用的。
1.Queue的使用
Queue接口与List、Set同一级别，都是继承了Collection接口。
Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如果要使用前端而不移出该元素，使用element()或者peek()方法。
值得注意的是LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。
Queue的方法也非常简单，就是三组(一个会抛出异常，一个返回特殊值):
| 方法 | 抛出异常 | 不会抛出异常 |
| 插入 | boolean add(E e); | boolean offer(E e); |
| 移除(返回且移除头元素) | E remove(); | E poll(); |
| 检查(返回头元素但不删除) | E element(); | E peek(); |
例如:(poll()返回了null，remove()抛出异常了)
package cn.qlq.thread.thirteen; import java.util.LinkedList; import java.util.Queue; public class Demo1 { public static void main(String[] args) { Queue<String> queue = new LinkedList<String>(); String poll = queue.poll(); System.out.println(poll); String remove = queue.remove(); System.out.println(remove); } }
结果:
null
Exception in thread "main" java.util.NoSuchElementException
at java.util.LinkedList.removeFirst(LinkedList.java:268)
at java.util.LinkedList.remove(LinkedList.java:683)
at cn.qlq.thread.thirteen.Demo1.main(Demo1.java:11)
2.BlockingQueue的使用
BlockingQueue继承Queue接口，位于并发包下，对Queue接口进行了扩展。
package java.util.concurrent; import java.util.Collection; import java.util.Queue; public interface BlockingQueue<E> extends Queue<E> { boolean add(E e); boolean offer(E e); void put(E e) throws InterruptedException; boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException; E take() throws InterruptedException; E poll(long timeout, TimeUnit unit) throws InterruptedException; int remainingCapacity(); boolean remove(Object o); public boolean contains(Object o); int drainTo(Collection<? super E> c); int drainTo(Collection<? super E> c, int maxElements); }
阻塞队列提供了可阻塞的put和take方法，以及支持定时的offer和poll方法。如果队列已经满了，那么put方法将阻塞到有空间可用；如果队列为空，那么take方法将会阻塞到有元素可用。队列可以是有界的，也可以是无界的，无界队列永远不会充满，因此无界队列的put方法永远也不会阻塞。(offer方法如果数据项不能添加到队列中，就会返回一个失败状态。这样就能够创建更多灵活的策略来处理负荷过载的情况，例如减轻负载，将多余的工作项序列化并写入磁盘，减少生产者线程的数量，或者通过某种方式来抑制生产者线程)
BlockingQueue简化了生产者-消费者模式的设计过程，消费者不需要知道生产者是谁，生产者也不需要知道生产者是谁；而且支持任意数量的生产者与消费者。一种最常见的生产者-消费者设计模式就是线程池与工作队列的组合，在Executor任务执行框架中就体现了这种模式。
一个经典的例子:以洗盘子为例子，一个人洗完盘子把盘子放在盘架上，另一个人负责从盘架上取出盘子并把他们烘干。在这个例子中，盘架就相当于一个阻塞队列。如果盘架上没有盘子，消费者会一直等待，如果盘架满了，生产者会一直等待。我们可以将这种类比扩展为多个生产者与多个消费者，每个工人只需要与盘架打交道。人们不需要知道谁是生产者谁是消费者。
生产者和消费者的角色是相对的，某种环境下的生产者在另一种不同的环境中可能会变为消费者。比如烘干盘子的人将"消费"洗干净的湿盘子，而产生烘干的盘子。第三个人把洗干净的盘子整理好，在这种情况下，烘干盘子的人是生产者也是消费者，从而就有了两个共享的队列(每个对垒对列可能阻塞烘干工作的运行)。
JDK中有多个BlockingQueue的实现，其中LinkedBlockingQueue和ArrayBlockingQueue是FIFO队列，二者分别于LinkedList和ArrayList类似，但比同步List拥有更好的同步性能。PriorityBlockingQueue队列是一个按优先级排列的队列，这个队列可以根据元素的自然顺序来比较元素(如果他们实现了Comparable方法)，也可以使用Comparator来比较。
还有一个是SynchronousQueue，实际上它不是一个真正的队列，因为它不会维护队列中元素的存储空间，与其他队列不同的是，它维护一组线程，这些线程在等待把元素加入或移除队列。如果以洗盘子为例，那么久相当于没有盘架而是直接将洗好的盘子放入下一个空闲的烘干机中。这种方式看似很奇怪，由于可以直接交付工作降低了将数据从生产者移到消费者的延迟。因为SynchronousQueue没有存储功能，因此put和take会一直阻塞，直到有另一个线程准备好参与到交付过程，仅当有足够多的消费者，并且总是有一个消费者准备获取交付工作时，才适合使用同步队列。
BlockingQueue中的方法:
BlockingQueue既然是Queue的子接口，必然有Queue中的方法，上面已经列了。看一下BlockingQueue中特有的方法：
（1）void put(E e) throws InterruptedException
把e添加进BlockingQueue中，如果BlockingQueue中没有空间，则调用线程被阻塞，进入等待状态，直到BlockingQueue中有空间再继续
（2）void take() throws InterruptedException
取走BlockingQueue里面排在首位的对象，如果BlockingQueue为空，则调用线程被阻塞，进入等待状态，直到BlockingQueue有新的数据被加入
（3）int drainTo(Collection<? super E> c, int maxElements)
一次性取走BlockingQueue中的数据到c中，可以指定取的个数。通过该方法可以提升获取数据效率，不需要多次分批加锁或释放锁
2.1 ArrayBlockingQueue的简单使用
基于数组的阻塞队列，必须指定队列大小。比较简单。ArrayBlockingQueue中只有一个ReentrantLock对象，这意味着生产者和消费者无法并行运行。创建ArrayBlockingQueue可以指定锁的公平性，默认是非公平锁，如下源码:
final ReentrantLock lock; private final Condition notEmpty; private final Condition notFull;
public ArrayBlockingQueue(int capacity) { this(capacity, false); } public ArrayBlockingQueue(int capacity, boolean fair) { if (capacity <= 0) throw new IllegalArgumentException(); this.items = new Object[capacity]; lock = new ReentrantLock(fair); notEmpty = lock.newCondition(); notFull = lock.newCondition(); }
例如:基于ArrayBlockingQueue的单生产单消费模式:
package cn.qlq.thread.thirteen; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Demo2 { private static int num ; private static final Logger LOGGER = LoggerFactory.getLogger(Demo2.class); public static void main(String[] args) throws InterruptedException { final BlockingQueue<String> strings = new ArrayBlockingQueue<>(1);//必须指定容量(指定容器最多为1) Thread producer = new Thread(new Runnable() { @Override public void run() { try { for (int i=0;i<5;i++) { String ele = "ele"+(++num); strings.put(ele); LOGGER.info("ThreadName ->{} put ele->{}",Thread.currentThread().getName(),ele); } } catch (InterruptedException e) { e.printStackTrace(); } } },"producer"); producer.start(); Thread consumer = new Thread(new Runnable() { @Override public void run() { try { for (int i=0;i<5;i++) { Thread.sleep(1*1000); String take = strings.take(); LOGGER.info("ThreadName ->{} take ele->{}",Thread.currentThread().getName(),take); } } catch (InterruptedException e) { e.printStackTrace(); } } },"consumer"); consumer.start(); } }
结果:(可以看到生产者放进元素之后会等元素被拿走之后才会继续生成元素)
11:00:04 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->producer put ele->ele1
11:00:05 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->consumer take ele->ele1
11:00:05 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->producer put ele->ele2
11:00:06 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->consumer take ele->ele2
11:00:06 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->producer put ele->ele3
11:00:07 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->producer put ele->ele4
11:00:07 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->consumer take ele->ele3
11:00:08 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->producer put ele->ele5
11:00:08 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->consumer take ele->ele4
11:00:09 [cn.qlq.thread.thirteen.Demo2]-[INFO] ThreadName ->consumer take ele->ele5
2.2 LinkedBlockingQueue 简单使用
类似于LinkedList，基于链表的阻塞队列。此队列如果不指定容量大小，默认采用Integer.MAX_VALUE(可以理解为无限队列)。此外LinkedBlockingList有两个锁，意味着生产者和消费者都有自己的锁。如下源码:
private 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(); public LinkedBlockingQueue() { this(Integer.MAX_VALUE); } public LinkedBlockingQueue(int capacity) { if (capacity <= 0) throw new IllegalArgumentException(); this.capacity = capacity; last = head = new Node<E>(null); } public LinkedBlockingQueue(Collection<? extends E> c) { this(Integer.MAX_VALUE); final ReentrantLock putLock = this.putLock; putLock.lock(); // Never contended, but necessary for visibility try { int n = 0; 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(); } }
例如:基于LinkedBlockingQueue的多生产多消费模式:
package cn.qlq.thread.thirteen; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Demo3 { private static int num ; private static final Logger LOGGER = LoggerFactory.getLogger(Demo3.class); public static void main(String[] args) throws InterruptedException { final BlockingQueue<String> strings = new LinkedBlockingQueue<>(3); Runnable producerRun = new Runnable() { @Override public synchronized void run() {//加同步避免出现线程非安全 try { for (int i=0;i<5;i++) { Thread.sleep(1000); String ele = "ele"+(++num); strings.put(ele); LOGGER.info("ThreadName ->{} put ele->{}",Thread.currentThread().getName(),ele); } } catch (InterruptedException e) { e.printStackTrace(); } } }; Thread producer = new Thread(producerRun,"producer"); producer.start(); Thread producer2 = new Thread(producerRun,"producer2"); producer2.start(); Runnable consumerRun = new Runnable() { @Override public void run() { try { for (int i=0;i<5;i++) { Thread.sleep(3000); String take = strings.take(); LOGGER.info("ThreadName ->{} take ele->{}",Thread.currentThread().getName(),take); } } catch (InterruptedException e) { e.printStackTrace(); } } }; Thread consumer = new Thread(consumerRun,"consumer"); Thread consumer1 = new Thread(consumerRun,"consumer1"); consumer.start(); consumer1.start(); } }
结果:
11:46:47 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer put ele->ele1
11:46:48 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer put ele->ele2
11:46:49 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer take ele->ele2
11:46:49 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer1 take ele->ele1
11:46:49 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer put ele->ele3
11:46:50 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer put ele->ele4
11:46:51 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer put ele->ele5
11:46:52 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer take ele->ele3
11:46:52 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer1 take ele->ele4
11:46:52 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer2 put ele->ele6
11:46:53 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer2 put ele->ele7
11:46:55 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer2 put ele->ele8
11:46:55 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer take ele->ele6
11:46:55 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer1 take ele->ele5
11:46:56 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer2 put ele->ele9
11:46:58 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer take ele->ele7
11:46:58 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer1 take ele->ele8
11:46:58 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->producer2 put ele->ele10
11:47:01 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer take ele->ele10
11:47:01 [cn.qlq.thread.thirteen.Demo3]-[INFO] ThreadName ->consumer1 take ele->ele9
2.3 PriorityBlockingQueue简单使用
PriorityBlockingQueue 是一个按优先级排列的阻塞队列，类似于TreeSet，看到tree，可以按顺序进行排列，就要想到两个接口。Comparable(集合中元素实现这个接口，元素自身具备可比性)，Comparator(比较器，传入容器构造方法中，容器具备可比性)。
其内部只有一个Lock，所以生产消费者不能同时作业，而且默认的容量是11，其构造方法也可以传入一个比较器，如下源码:
/** * Default array capacity. */ private static final int DEFAULT_INITIAL_CAPACITY = 11; public PriorityBlockingQueue() { this(DEFAULT_INITIAL_CAPACITY, null); } public PriorityBlockingQueue(int initialCapacity) { this(initialCapacity, null); } public PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator) { if (initialCapacity < 1) throw new IllegalArgumentException(); this.lock = new ReentrantLock(); this.notEmpty = lock.newCondition(); this.comparator = comparator; this.queue = new Object[initialCapacity]; } public PriorityBlockingQueue(Collection<? extends E> c) { this.lock = new ReentrantLock(); this.notEmpty = lock.newCondition(); boolean heapify = true; // true if not known to be in heap order boolean screen = true; // true if must screen for nulls if (c instanceof SortedSet<?>) { SortedSet<? extends E> ss = (SortedSet<? extends E>) c; this.comparator = (Comparator<? super E>) ss.comparator(); heapify = false; } else if (c instanceof PriorityBlockingQueue<?>) { PriorityBlockingQueue<? extends E> pq = (PriorityBlockingQueue<? extends E>) c; this.comparator = (Comparator<? super E>) pq.comparator(); screen = false; if (pq.getClass() == PriorityBlockingQueue.class) // exact match heapify = false; } Object[] a = c.toArray(); int n = a.length; // If c.toArray incorrectly doesn't return Object[], copy it. if (a.getClass() != Object[].class) a = Arrays.copyOf(a, n, Object[].class); if (screen && (n == 1 || this.comparator != null)) { for (int i = 0; i < n; ++i) if (a[i] == null) throw new NullPointerException(); } this.queue = a; this.size = n; if (heapify) heapify(); }
测试按年龄逆序排列:
package cn.qlq.thread.thirteen; import java.util.concurrent.BlockingQueue; import java.util.concurrent.PriorityBlockingQueue; public class Demo4 { public static void main(String[] args) throws InterruptedException { BlockingQueue<Person> persons = new PriorityBlockingQueue<Person>(3); persons.put(new Person(20,"張三")); persons.put(new Person(22,"李四")); persons.put(new Person(21,"王五")); persons.put(new Person(18,"八卦")); System.out.println(persons.take()); System.out.println(persons.take()); System.out.println(persons.take()); System.out.println(persons.take()); } } class Person implements Comparable<Person>{ private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person [age=" + age + ", name=" + name + "]"; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Person(int age, String name) { super(); this.age = age; this.name = name; } @Override public int compareTo(Person o) {//返回-1表示排在他前面，返回1表示排在他后面 if(o.getAge() > this.getAge() ){ return 1; }else if(o.getAge() < this.getAge()){ return -1; } return 0; } }
结果:
Person [age=22, name=李四]
Person [age=21, name=王五]
Person [age=20, name=張三]
Person [age=18, name=八卦]
2.4 SynchronousQueue简单使用
前面已经介绍了，SynchronousQueue实际上它不是一个真正的队列，因为它不会维护队列中元素的存储空间，与其他队列不同的是，它维护一组线程，这些线程在等待把元素加入或移除队列。适用于生产者少消费者多的情况。
例如:
ArrayBlockingQueue有一个数组存储队列元素:
/** The queued items */ final Object[] items;
LinedBlockingQueue有一个内部Node类存储元素:
/** * Linked list node class */ static class Node<E> { E item;
Node<E> next; Node(E x) { item = x; } }
PriorityBlockingQueue有一个数组用于存储元素
private transient Object[] queue;
可以这么理解，SynchronousQueue是生产者直接把数据给消费者（消费者直接从生产者这里拿数据）。换句话说，每一个插入操作必须等待一个线程对应的移除操作。SynchronousQueue又有两种模式：
1、公平模式
采用公平锁，并配合一个FIFO队列（Queue）来管理多余的生产者和消费者
2、非公平模式
采用非公平锁，并配合一个LIFO栈（Stack）来管理多余的生产者和消费者，这也是SynchronousQueue默认的模式
如下源码:
public SynchronousQueue() { this(false); } public SynchronousQueue(boolean fair) { transferer = fair ? new TransferQueue() : new TransferStack(); }
transferer 是一个内部类用于在生产者和消费者之间传递数据
abstract static class Transferer { /** * Performs a put or take. **/ abstract Object transfer(Object e, boolean timed, long nanos); }
例如:直接put元素会阻塞
package cn.qlq.thread.thirteen; import java.util.concurrent.BlockingQueue; import java.util.concurrent.SynchronousQueue; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Demo5 { private static final Logger LOGGER = LoggerFactory.getLogger(Demo5.class); public static void main(String[] args) throws InterruptedException { BlockingQueue<String> persons = new SynchronousQueue<String>(); persons.put("1"); LOGGER.info("放入元素 1"); LOGGER.info("獲取元素 "+persons.take()); } }
结果:(线程会一直处于阻塞状态,由于没有消费者线程消费元素所以一直处于阻塞，所以不会执行LOGGER.info()的代码)
解决办法:生产元素之前，先开启消费者线程:(也就是必须确保生产的元素有消费者在take(),否则会阻塞)
package cn.qlq.thread.thirteen; import java.util.concurrent.BlockingQueue; import java.util.concurrent.SynchronousQueue; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Demo5 { private static final Logger LOGGER = LoggerFactory.getLogger(Demo5.class); public static void main(String[] args) throws InterruptedException { final BlockingQueue<String> strings = new SynchronousQueue<String>(); Thread consumer = new Thread(new Runnable() { @Override public void run() { try { String take = strings.take(); LOGGER.info("ThreadName ->{} take ele->{}",Thread.currentThread().getName(),take); } catch (InterruptedException e) { e.printStackTrace(); } } },"consumer"); consumer.start(); strings.put("1"); LOGGER.info("放入元素 1"); } }
结果:(正常打印信息，并且进程也结束)
2.5 还有一个延迟队列DelayQueue---此队列可以实现有序与延迟的效果
DelayQueue是一个无界阻塞队列，只有在延迟期满时才能从中提取元素。(获取元素的时候获取的是头部元素，而且头部元素只有在延迟期小于0才可以取出来)
为了具有调用行为，存放到DelayDeque的元素必须继承Delayed接口。Delayed接口使对象成为延迟对象，它使存放在DelayQueue类中的对象具有了激活日期。该接口继承Comparable接口，如下:
public interface Delayed extends Comparable<Delayed> { long getDelay(TimeUnit unit); }
CompareTo(Delayed o)：Delayed接口继承了Comparable接口，因此有了这个方法。
getDelay(TimeUnit unit):这个方法返回到激活日期的剩余时间，时间单位由单位参数指定。(返回值为负数的时候才可以take()出来)
此类也是只有一把锁，而且内部维护一个PriorityQueue用于存放有序队列(实现有序)，查看源码:
private transient final ReentrantLock lock = new ReentrantLock(); private final PriorityQueue<E> q = new PriorityQueue<E>(); private Thread leader = null; public DelayQueue() {} public DelayQueue(Collection<? extends E> c) { this.addAll(c); } 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(TimeUnit.NANOSECONDS); if (delay <= 0) return q.poll(); else 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(); } }
例如:测试队列中放入5s以后的元素才可以取出来:
package cn.qlq.thread.thirteen; import java.util.Date; import java.util.concurrent.BlockingQueue; import java.util.concurrent.DelayQueue; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Demo6 { private static final Logger LOGGER = LoggerFactory.getLogger(Demo6.class); public static void main(String[] args) throws InterruptedException { final BlockingQueue<DelayObj> delayObjs = new DelayQueue<DelayObj>(); DelayObj delayObj = new DelayObj("1"); delayObjs.put(delayObj); LOGGER.info("放入元素->{}", delayObj); Thread.sleep(1 * 1000); DelayObj delayObj2 = new DelayObj("3"); delayObjs.put(delayObj2); LOGGER.info("放入元素->{}", delayObj2); LOGGER.info("{}", delayObjs.take()); LOGGER.info("{}", delayObjs.take()); } } class DelayObj implements Delayed { private Date createTime; private String name; public Date getCreateTime() { return createTime; } public void setCreateTime(Date createTime) { this.createTime = createTime; } public DelayObj(String name) { this.createTime = new Date(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public int compareTo(Delayed o) { // 返回负数表示在前面，返回正数表示在后面 if (this.getDelay(TimeUnit.NANOSECONDS) > o.getDelay(TimeUnit.NANOSECONDS)) {// NANOSECONDS是十亿分之秒 return -1; } else if (this.getDelay(TimeUnit.NANOSECONDS) < o.getDelay(TimeUnit.NANOSECONDS)) { return 1; } return 0; } @Override public String toString() { return "DelayObj [createTime=" + createTime + ", name=" + name + "]"; } @Override public long getDelay(TimeUnit unit) { Date now = new Date(); long diff = createTime.getTime() + 5 * 1000 - now.getTime(); System.out.println(diff); return unit.convert(diff, TimeUnit.MILLISECONDS); } }
结果: (可以看到先获取的是最后创建的元素，而且只有在延迟期为0才可以获取到---实现了有序加延迟)
23:10:44 [cn.qlq.thread.thirteen.Demo6]-[INFO] 放入元素->DelayObj [createTime=Wed Dec 26 23:10:44 CST 2018, name=1]
4997
3976
23:10:45 [cn.qlq.thread.thirteen.Demo6]-[INFO] 放入元素->DelayObj [createTime=Wed Dec 26 23:10:45 CST 2018, name=3]
4991
-3
23:10:50 [cn.qlq.thread.thirteen.Demo6]-[INFO] DelayObj [createTime=Wed Dec 26 23:10:45 CST 2018, name=3]
-1023
23:10:50 [cn.qlq.thread.thirteen.Demo6]-[INFO] DelayObj [createTime=Wed Dec 26 23:10:44 CST 2018, name=1]
补充： 阻塞队列简单原理
查看 LinkedBlockingQueue 源码：
/* * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */ package java.util.concurrent; import java.util.AbstractQueue; import java.util.Collection; import java.util.Iterator; import java.util.NoSuchElementException; import java.util.Objects; import java.util.Spliterator; import java.util.Spliterators; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; import java.util.function.Consumer; import java.util.function.Predicate; /** * An optionally-bounded {@linkplain BlockingQueue blocking queue} based on * linked nodes. * This queue orders elements FIFO (first-in-first-out). * The <em>head</em> of the queue is that element that has been on the * queue the longest time. * The <em>tail</em> of the queue is that element that has been on the * queue the shortest time. New elements * are inserted at the tail of the queue, and the queue retrieval * operations obtain elements at the head of the queue. * Linked queues typically have higher throughput than array-based queues but * less predictable performance in most concurrent applications. * * <p>The optional capacity bound constructor argument serves as a * way to prevent excessive queue expansion. The capacity, if unspecified, * is equal to {@link Integer#MAX_VALUE}. Linked nodes are * dynamically created upon each insertion unless this would bring the * queue above capacity. * * <p>This class and its iterator implement all of the <em>optional</em> * methods of the {@link Collection} and {@link Iterator} interfaces. * * <p>This class is a member of the * <a href="{@docRoot}/java.base/java/util/package-summary.html#CollectionsFramework"> * Java Collections Framework</a>. * * @since 1.5 * @author Doug Lea * @param <E> the type of elements held in this queue */ public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable { private static final long serialVersionUID = -6903933977591709194L; /* * A variant of the "two lock queue" algorithm. The putLock gates * entry to put (and offer), and has an associated condition for * waiting puts. Similarly for the takeLock. The "count" field * that they both rely on is maintained as an atomic to avoid * needing to get both locks in most cases. Also, to minimize need * for puts to get takeLock and vice-versa, cascading notifies are * used. When a put notices that it has enabled at least one take, * it signals taker. That taker in turn signals others if more * items have been entered since the signal. And symmetrically for * takes signalling puts. Operations such as remove(Object) and * iterators acquire both locks. * * Visibility between writers and readers is provided as follows: * * Whenever an element is enqueued, the putLock is acquired and * count updated. A subsequent reader guarantees visibility to the * enqueued Node by either acquiring the putLock (via fullyLock) * or by acquiring the takeLock, and then reading n = count.get(); * this gives visibility to the first n items. * * To implement weakly consistent iterators, it appears we need to * keep all Nodes GC-reachable from a predecessor dequeued Node. * That would cause two problems: * - allow a rogue Iterator to cause unbounded memory retention * - cause cross-generational linking of old Nodes to new Nodes if * a Node was tenured while live, which generational GCs have a * hard time dealing with, causing repeated major collections. * However, only non-deleted Nodes need to be reachable from * dequeued Nodes, and reachability does not necessarily have to * be of the kind understood by the GC. We use the trick of * linking a Node that has just been dequeued to itself. Such a * self-link implicitly means to advance to head.next. */ /** * Linked list node class. */ static class Node<E> { E item; /** * One of: * - the real successor Node * - this Node, meaning the successor is head.next * - null, meaning there is no successor (this is the last node) */ Node<E> next; Node(E x) { item = x; } } /** The capacity bound, or Integer.MAX_VALUE if none */ private final int capacity; /** Current number of elements */ private final AtomicInteger count = new AtomicInteger(); /** * Head of linked list. * Invariant: head.item == null */ transient Node<E> head; /** * Tail of linked list. * Invariant: last.next == null */ private transient Node<E> last; /** Lock held by take, poll, etc */ private final ReentrantLock takeLock = new ReentrantLock(); /** Wait queue for waiting takes */ private final Condition notEmpty = takeLock.newCondition(); /** Lock held by put, offer, etc */ private final ReentrantLock putLock = new ReentrantLock(); /** Wait queue for waiting puts */ private final Condition notFull = putLock.newCondition(); /** * Signals a waiting take. Called only from put/offer (which do not * otherwise ordinarily lock takeLock.) */ private void signalNotEmpty() { final ReentrantLock takeLock = this.takeLock; takeLock.lock(); try { notEmpty.signal(); } finally { takeLock.unlock(); } } /** * Signals a waiting put. Called only from take/poll. */ private void signalNotFull() { final ReentrantLock putLock = this.putLock; putLock.lock(); try { notFull.signal(); } finally { putLock.unlock(); } } /** * Links node at end of queue. * * @param node the node */ private void enqueue(Node<E> node) { // assert putLock.isHeldByCurrentThread(); // assert last.next == null; last = last.next = node; } /** * Removes a node from head of queue. * * @return the node */ private E dequeue() { // assert takeLock.isHeldByCurrentThread(); // assert head.item == null; 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; } /** * Locks to prevent both puts and takes. */ void fullyLock() { putLock.lock(); takeLock.lock(); } /** * Unlocks to allow both puts and takes. */ void fullyUnlock() { takeLock.unlock(); putLock.unlock(); } /** * Creates a {@code LinkedBlockingQueue} with a capacity of * {@link Integer#MAX_VALUE}. */ public LinkedBlockingQueue() { this(Integer.MAX_VALUE); } /** * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity. * * @param capacity the capacity of this queue * @throws IllegalArgumentException if {@code capacity} is not greater * than zero */ public LinkedBlockingQueue(int capacity) { if (capacity <= 0) throw new IllegalArgumentException(); this.capacity = capacity; last = head = new Node<E>(null); } /** * Creates a {@code LinkedBlockingQueue} with a capacity of * {@link Integer#MAX_VALUE}, initially containing the elements of the * given collection, * added in traversal order of the collection's iterator. * * @param c the collection of elements to initially contain * @throws NullPointerException if the specified collection or any * of its elements are null */ public LinkedBlockingQueue(Collection<? extends E> c) { this(Integer.MAX_VALUE); final ReentrantLock putLock = this.putLock; putLock.lock(); // Never contended, but necessary for visibility try { int n = 0; 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(); } } // this doc comment is overridden to remove the reference to collections // greater in size than Integer.MAX_VALUE /** * Returns the number of elements in this queue. * * @return the number of elements in this queue */ public int size() { return count.get(); } // this doc comment is a modified copy of the inherited doc comment, // without the reference to unlimited queues. /** * Returns the number of additional elements that this queue can ideally * (in the absence of memory or resource constraints) accept without * blocking. This is always equal to the initial capacity of this queue * less the current {@code size} of this queue. * * <p>Note that you <em>cannot</em> always tell if an attempt to insert * an element will succeed by inspecting {@code remainingCapacity} * because it may be the case that another thread is about to * insert or remove an element. */ public int remainingCapacity() { return capacity - count.get(); } /** * Inserts the specified element at the tail of this queue, waiting if * necessary for space to become available. * * @throws InterruptedException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public void put(E e) throws InterruptedException { if (e == null) throw new NullPointerException(); final int c; final Node<E> node = new Node<E>(e); final ReentrantLock putLock = this.putLock; final AtomicInteger count = this.count; putLock.lockInterruptibly(); try { /* * Note that count is used in wait guard even though it is * not protected by lock. This works because count can * only decrease at this point (all other puts are shut * out by lock), and we (or some other waiting put) are * signalled if it ever changes from capacity. Similarly * for all other uses of count in other wait guards. */ while (count.get() == capacity) { notFull.await(); } enqueue(node); c = count.getAndIncrement(); if (c + 1 < capacity) notFull.signal(); } finally { putLock.unlock(); } if (c == 0) signalNotEmpty(); } /** * Inserts the specified element at the tail of this queue, waiting if * necessary up to the specified wait time for space to become available. * * @return {@code true} if successful, or {@code false} if * the specified waiting time elapses before space is available * @throws InterruptedException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */ public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException { if (e == null) throw new NullPointerException(); long nanos = unit.toNanos(timeout); final int c; final ReentrantLock putLock = this.putLock; final AtomicInteger count = this.count; putLock.lockInterruptibly(); try { while (count.get() == capacity) { if (nanos <= 0L) 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; } /** * Inserts the specified element at the tail of this queue if it is * possible to do so immediately without exceeding the queue's capacity, * returning {@code true} upon success and {@code false} if this queue * is full. * When using a capacity-restricted queue, this method is generally * preferable to method {@link BlockingQueue#add add}, which can fail to * insert an element only by throwing an exception. * * @throws NullPointerException if the specified element is null */ public boolean offer(E e) { if (e == null) throw new NullPointerException(); final AtomicInteger count = this.count; if (count.get() == capacity) return false; final int c; final Node<E> node = new Node<E>(e); final ReentrantLock putLock = this.putLock; putLock.lock(); try { if (count.get() == capacity) return false; enqueue(node); c = count.getAndIncrement(); if (c + 1 < capacity) notFull.signal(); } finally { putLock.unlock(); } if (c == 0) signalNotEmpty(); return true; } public E take() throws InterruptedException { final E x; final int c; final AtomicInteger count = this.count; final ReentrantLock takeLock = this.takeLock; takeLock.lockInterruptibly(); try { while (count.get() == 0) { notEmpty.await(); } x = dequeue(); c = count.getAndDecrement(); if (c > 1) notEmpty.signal(); } finally { takeLock.unlock(); } if (c == capacity) signalNotFull(); return x; } public E poll(long timeout, TimeUnit unit) throws InterruptedException { final E x; final int c; long nanos = unit.toNanos(timeout); final AtomicInteger count = this.count; final ReentrantLock takeLock = this.takeLock; takeLock.lockInterruptibly(); try { while (count.get() == 0) { if (nanos <= 0L) 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; if (count.get() == 0) return null; final E x; final int c; final ReentrantLock takeLock = this.takeLock; takeLock.lock(); try { if (count.get() == 0) return null; x = dequeue(); c = count.getAndDecrement(); if (c > 1) notEmpty.signal(); } finally { takeLock.unlock(); } if (c == capacity) signalNotFull(); return x; } public E peek() { final AtomicInteger count = this.count; if (count.get() == 0) return null; final ReentrantLock takeLock = this.takeLock; takeLock.lock(); try { return (count.get() > 0) ? head.next.item : null; } finally { takeLock.unlock(); } } /** * Unlinks interior Node p with predecessor pred. */ void unlink(Node<E> p, Node<E> pred) { // assert putLock.isHeldByCurrentThread(); // assert takeLock.isHeldByCurrentThread(); // p.next is not changed, to allow iterators that are // traversing p to maintain their weak-consistency guarantee. p.item = null; pred.next = p.next; if (last == p) last = pred; if (count.getAndDecrement() == capacity) notFull.signal(); } /** * Removes a single instance of the specified element from this queue, * if it is present. More formally, removes an element {@code e} such * that {@code o.equals(e)}, if this queue contains one or more such * elements. * Returns {@code true} if this queue contained the specified element * (or equivalently, if this queue changed as a result of the call). * * @param o element to be removed from this queue, if present * @return {@code true} if this queue changed as a result of the call */ public boolean remove(Object o) { if (o == null) return false; fullyLock(); try { for (Node<E> pred = head, p = pred.next; p != null; pred = p, p = p.next) { if (o.equals(p.item)) { unlink(p, pred); return true; } } return false; } finally { fullyUnlock(); } } /** * Returns {@code true} if this queue contains the specified element. * More formally, returns {@code true} if and only if this queue contains * at least one element {@code e} such that {@code o.equals(e)}. * * @param o object to be checked for containment in this queue * @return {@code true} if this queue contains the specified element */ public boolean contains(Object o) { if (o == null) return false; fullyLock(); try { for (Node<E> p = head.next; p != null; p = p.next) if (o.equals(p.item)) return true; return false; } finally { fullyUnlock(); } } /** * Returns an array containing all of the elements in this queue, in * proper sequence. * * <p>The returned array will be "safe" in that no references to it are * maintained by this queue. (In other words, this method must allocate * a new array). The caller is thus free to modify the returned array. * * <p>This method acts as bridge between array-based and collection-based * APIs. * * @return an array containing all of the elements in this queue */ public Object[] toArray() { fullyLock(); try { int size = count.get(); Object[] a = new Object[size]; int k = 0; for (Node<E> p = head.next; p != null; p = p.next) a[k++] = p.item; return a; } finally { fullyUnlock(); } } /** * Returns an array containing all of the elements in this queue, in * proper sequence; the runtime type of the returned array is that of * the specified array. If the queue fits in the specified array, it * is returned therein. Otherwise, a new array is allocated with the * runtime type of the specified array and the size of this queue. * * <p>If this queue fits in the specified array with room to spare * (i.e., the array has more elements than this queue), the element in * the array immediately following the end of the queue is set to * {@code null}. * * <p>Like the {@link #toArray()} method, this method acts as bridge between * array-based and collection-based APIs. Further, this method allows * precise control over the runtime type of the output array, and may, * under certain circumstances, be used to save allocation costs. * * <p>Suppose {@code x} is a queue known to contain only strings. * The following code can be used to dump the queue into a newly * allocated array of {@code String}: * * <pre> {@code String[] y = x.toArray(new String[0]);}</pre> * * Note that {@code toArray(new Object[0])} is identical in function to * {@code toArray()}. * * @param a the array into which the elements of the queue are to * be stored, if it is big enough; otherwise, a new array of the * same runtime type is allocated for this purpose * @return an array containing all of the elements in this queue * @throws ArrayStoreException if the runtime type of the specified array * is not a supertype of the runtime type of every element in * this queue * @throws NullPointerException if the specified array is null */ @SuppressWarnings("unchecked") public <T> T[] toArray(T[] a) { fullyLock(); try { int size = count.get(); if (a.length < size) a = (T[])java.lang.reflect.Array.newInstance (a.getClass().getComponentType(), size); int k = 0; for (Node<E> p = head.next; p != null; p = p.next) a[k++] = (T)p.item; if (a.length > k) a[k] = null; return a; } finally { fullyUnlock(); } } public String toString() { return Helpers.collectionToString(this); } /** * Atomically removes all of the elements from this queue. * The queue will be empty after this call returns. */ public void clear() { fullyLock(); try { for (Node<E> p, h = head; (p = h.next) != null; h = p) { h.next = h; p.item = null; } head = last; // assert head.item == null && head.next == null; if (count.getAndSet(0) == capacity) notFull.signal(); } finally { fullyUnlock(); } } /** * @throws UnsupportedOperationException {@inheritDoc} * @throws ClassCastException {@inheritDoc} * @throws NullPointerException {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc} */ public int drainTo(Collection<? super E> c) { return drainTo(c, Integer.MAX_VALUE); } /** * @throws UnsupportedOperationException {@inheritDoc} * @throws ClassCastException {@inheritDoc} * @throws NullPointerException {@inheritDoc} * @throws IllegalArgumentException {@inheritDoc} */ public int drainTo(Collection<? super E> c, int maxElements) { Objects.requireNonNull(c); if (c == this) throw new IllegalArgumentException(); if (maxElements <= 0) return 0; boolean signalNotFull = false; final ReentrantLock takeLock = this.takeLock; takeLock.lock(); try { int n = Math.min(maxElements, count.get()); // count.get provides visibility to first n Nodes Node<E> h = head; int i = 0; try { while (i < n) { Node<E> p = h.next; c.add(p.item); p.item = null; h.next = h; h = p; ++i; } return n; } finally { // Restore invariants even if c.add() threw if (i > 0) { // assert h.item == null; head = h; signalNotFull = (count.getAndAdd(-i) == capacity); } } } finally { takeLock.unlock(); if (signalNotFull) signalNotFull(); } } /** * Used for any element traversal that is not entirely under lock. * Such traversals must handle both: * - dequeued nodes (p.next == p) * - (possibly multiple) interior removed nodes (p.item == null) */ Node<E> succ(Node<E> p) { if (p == (p = p.next)) p = head.next; return p; } /** * Returns an iterator over the elements in this queue in proper sequence. * The elements will be returned in order from first (head) to last (tail). * * <p>The returned iterator is * <a href="package-summary.html#Weakly"><i>weakly consistent</i></a>. * * @return an iterator over the elements in this queue in proper sequence */ public Iterator<E> iterator() { return new Itr(); } /** * Weakly-consistent iterator. * * Lazily updated ancestor field provides expected O(1) remove(), * but still O(n) in the worst case, whenever the saved ancestor * is concurrently deleted. */ private class Itr implements Iterator<E> { private Node<E> next; // Node holding nextItem private E nextItem; // next item to hand out private Node<E> lastRet; private Node<E> ancestor; // Helps unlink lastRet on remove() Itr() { fullyLock(); try { if ((next = head.next) != null) nextItem = next.item; } finally { fullyUnlock(); } } public boolean hasNext() { return next != null; } public E next() { Node<E> p; if ((p = next) == null) throw new NoSuchElementException(); lastRet = p; E x = nextItem; fullyLock(); try { E e = null; for (p = p.next; p != null && (e = p.item) == null; ) p = succ(p); next = p; nextItem = e; } finally { fullyUnlock(); } return x; } public void forEachRemaining(Consumer<? super E> action) { // A variant of forEachFrom Objects.requireNonNull(action); Node<E> p; if ((p = next) == null) return; lastRet = p; next = null; final int batchSize = 64; Object[] es = null; int n, len = 1; do { fullyLock(); try { if (es == null) { p = p.next; for (Node<E> q = p; q != null; q = succ(q)) if (q.item != null && ++len == batchSize) break; es = new Object[len]; es[0] = nextItem; nextItem = null; n = 1; } else n = 0; for (; p != null && n < len; p = succ(p)) if ((es[n] = p.item) != null) { lastRet = p; n++; } } finally { fullyUnlock(); } for (int i = 0; i < n; i++) { @SuppressWarnings("unchecked") E e = (E) es[i]; action.accept(e); } } while (n > 0 && p != null); } public void remove() { Node<E> p = lastRet; if (p == null) throw new IllegalStateException(); lastRet = null; fullyLock(); try { if (p.item != null) { if (ancestor == null) ancestor = head; ancestor = findPred(p, ancestor); unlink(p, ancestor); } } finally { fullyUnlock(); } } } /** * A customized variant of Spliterators.IteratorSpliterator. * Keep this class in sync with (very similar) LBDSpliterator. */ private final class LBQSpliterator implements Spliterator<E> { static final int MAX_BATCH = 1 << 25; // max batch array size; Node<E> current; // current node; null until initialized int batch; // batch size for splits boolean exhausted; // true when no more nodes long est = size(); // size estimate LBQSpliterator() {} public long estimateSize() { return est; } public Spliterator<E> trySplit() { Node<E> h; if (!exhausted && ((h = current) != null || (h = head.next) != null) && h.next != null) { int n = batch = Math.min(batch + 1, MAX_BATCH); Object[] a = new Object[n]; int i = 0; Node<E> p = current; fullyLock(); try { if (p != null || (p = head.next) != null) for (; p != null && i < n; p = succ(p)) if ((a[i] = p.item) != null) i++; } finally { fullyUnlock(); } if ((current = p) == null) { est = 0L; exhausted = true; } else if ((est -= i) < 0L) est = 0L; if (i > 0) return Spliterators.spliterator (a, 0, i, (Spliterator.ORDERED | Spliterator.NONNULL | Spliterator.CONCURRENT)); } return null; } public boolean tryAdvance(Consumer<? super E> action) { Objects.requireNonNull(action); if (!exhausted) { E e = null; fullyLock(); try { Node<E> p; if ((p = current) != null || (p = head.next) != null) do { e = p.item; p = succ(p); } while (e == null && p != null); if ((current = p) == null) exhausted = true; } finally { fullyUnlock(); } if (e != null) { action.accept(e); return true; } } return false; } public void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); if (!exhausted) { exhausted = true; Node<E> p = current; current = null; forEachFrom(action, p); } } public int characteristics() { return (Spliterator.ORDERED | Spliterator.NONNULL | Spliterator.CONCURRENT); } } /** * Returns a {@link Spliterator} over the elements in this queue. * * <p>The returned spliterator is * <a href="package-summary.html#Weakly"><i>weakly consistent</i></a>. * * <p>The {@code Spliterator} reports {@link Spliterator#CONCURRENT}, * {@link Spliterator#ORDERED}, and {@link Spliterator#NONNULL}. * * @implNote * The {@code Spliterator} implements {@code trySplit} to permit limited * parallelism. * * @return a {@code Spliterator} over the elements in this queue * @since 1.8 */ public Spliterator<E> spliterator() { return new LBQSpliterator(); } /** * @throws NullPointerException {@inheritDoc} */ public void forEach(Consumer<? super E> action) { Objects.requireNonNull(action); forEachFrom(action, null); } /** * Runs action on each element found during a traversal starting at p. * If p is null, traversal starts at head. */ void forEachFrom(Consumer<? super E> action, Node<E> p) { // Extract batches of elements while holding the lock; then // run the action on the elements while not final int batchSize = 64; // max number of elements per batch Object[] es = null; // container for batch of elements int n, len = 0; do { fullyLock(); try { if (es == null) { if (p == null) p = head.next; for (Node<E> q = p; q != null; q = succ(q)) if (q.item != null && ++len == batchSize) break; es = new Object[len]; } for (n = 0; p != null && n < len; p = succ(p)) if ((es[n] = p.item) != null) n++; } finally { fullyUnlock(); } for (int i = 0; i < n; i++) { @SuppressWarnings("unchecked") E e = (E) es[i]; action.accept(e); } } while (n > 0 && p != null); } /** * @throws NullPointerException {@inheritDoc} */ public boolean removeIf(Predicate<? super E> filter) { Objects.requireNonNull(filter); return bulkRemove(filter); } /** * @throws NullPointerException {@inheritDoc} */ public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); return bulkRemove(e -> c.contains(e)); } /** * @throws NullPointerException {@inheritDoc} */ public boolean retainAll(Collection<?> c) { Objects.requireNonNull(c); return bulkRemove(e -> !c.contains(e)); } /** * Returns the predecessor of live node p, given a node that was * once a live ancestor of p (or head); allows unlinking of p. */ Node<E> findPred(Node<E> p, Node<E> ancestor) { // assert p.item != null; if (ancestor.item == null) ancestor = head; // Fails with NPE if precondition not satisfied for (Node<E> q; (q = ancestor.next) != p; ) ancestor = q; return ancestor; } /** Implementation of bulk remove methods. */ @SuppressWarnings("unchecked") private boolean bulkRemove(Predicate<? super E> filter) { boolean removed = false; Node<E> p = null, ancestor = head; Node<E>[] nodes = null; int n, len = 0; do { // 1. Extract batch of up to 64 elements while holding the lock. fullyLock(); try { if (nodes == null) { // first batch; initialize p = head.next; for (Node<E> q = p; q != null; q = succ(q)) if (q.item != null && ++len == 64) break; nodes = (Node<E>[]) new Node<?>[len]; } for (n = 0; p != null && n < len; p = succ(p)) nodes[n++] = p; } finally { fullyUnlock(); } // 2. Run the filter on the elements while lock is free. long deathRow = 0L; // "bitset" of size 64 for (int i = 0; i < n; i++) { final E e; if ((e = nodes[i].item) != null && filter.test(e)) deathRow |= 1L << i; } // 3. Remove any filtered elements while holding the lock. if (deathRow != 0) { fullyLock(); try { for (int i = 0; i < n; i++) { final Node<E> q; if ((deathRow & (1L << i)) != 0L && (q = nodes[i]).item != null) { ancestor = findPred(q, ancestor); unlink(q, ancestor); removed = true; } nodes[i] = null; // help GC } } finally { fullyUnlock(); } } } while (n > 0 && p != null); return removed; } /** * Saves this queue to a stream (that is, serializes it). * * @param s the stream * @throws java.io.IOException if an I/O error occurs * @serialData The capacity is emitted (int), followed by all of * its elements (each an {@code Object}) in the proper order, * followed by a null */ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { fullyLock(); try { // Write out any hidden stuff, plus capacity s.defaultWriteObject(); // Write out all elements in the proper order. for (Node<E> p = head.next; p != null; p = p.next) s.writeObject(p.item); // Use trailing null as sentinel s.writeObject(null); } finally { fullyUnlock(); } } /** * Reconstitutes this queue from a stream (that is, deserializes it). * @param s the stream * @throws ClassNotFoundException if the class of a serialized object * could not be found * @throws java.io.IOException if an I/O error occurs */ private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in capacity, and any hidden stuff s.defaultReadObject(); count.set(0); last = head = new Node<E>(null); // Read in all elements and place in queue for (;;) { @SuppressWarnings("unchecked") E item = (E)s.readObject(); if (item == null) break; add(item); } } }
1. 以put 方法为例查看源码
java.util.concurrent.LinkedBlockingQueue#put
逻辑是：
1》 先 获取锁
2》 如果容量满了就调用notFull.await(); 将当前线程阻塞。最终调用的是：java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject#await()
public final void await() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Node node = addConditionWaiter(); int savedState = fullyRelease(node); int interruptMode = 0; while (!isOnSyncQueue(node)) { LockSupport.park(this); if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; } if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode = REINTERRUPT; if (node.nextWaiter != null) // clean up if cancelled unlinkCancelledWaiters(); if (interruptMode != 0) reportInterruptAfterWait(interruptMode); }
可以看到最终是先释放掉资源， 然后调用 LockSupport.park(this); 将线程进行阻塞， 线程进入等待状态。 这个和synchronized 一样，最终调到内核的 futex 指令。
当线程从await 恢复之后，会尝试acquireQueued 再次获取锁， 获取到之后返回去。
3》 如果被唤醒或者上面没达到容量， 则放一个元素到队列， 然后容量自增。然后判断是否容量还有余下的空间，如果空间还有余， 调用 notFull.signal(); 唤醒其他阻塞的线程。(会在当前线程解锁后其他等待的线程恢复后即系走上面逻辑)。 调用到：java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject#signal
public final void signal() { if (!isHeldExclusively()) throw new IllegalMonitorStateException(); Node first = firstWaiter; if (first != null) doSignal(first); } private void doSignal(Node first) { do { if ( (firstWaiter = first.nextWaiter) == null) lastWaiter = null; first.nextWaiter = null; } while (!transferForSignal(first) && (first = firstWaiter) != null); } final boolean transferForSignal(Node node) { /* * If cannot change waitStatus, the node has been cancelled. */ if (!node.compareAndSetWaitStatus(Node.CONDITION, 0)) return false; /* * Splice onto queue and try to set waitStatus of predecessor to * indicate that thread is (probably) waiting. If cancelled or * attempt to set waitStatus fails, wake up to resync (in which * case the waitStatus can be transiently and harmlessly wrong). */ Node p = enq(node); int ws = p.waitStatus; if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL)) LockSupport.unpark(node.thread); return true; }
将等待队列中等待时间最长的节点移动到同步队列中。 移入到同步队列后才有机会使得等待线程被唤醒，即从await方法中的LockSupport.park(this)方法中返回，从而才有机会使得调用await方法的线程成功退出。
4》 最后判断如果原来容量为0， 就调用notEmpty.signal(); 唤醒消费者
2. take 方法逻辑和上面逻辑正好相反。 属于消费者的逻辑。
【当你用心写完每一篇博客之后,你会发现它比你用代码实现功能更有成就感!】
