基于单向链表实现,将每一个元素封装成一个Node,Node有当前值,还有一个next指针,一般成为无界队列,LinkedBlockingQueue内部提供了读锁和写锁,读写不互斥,而且记录数据条数的属性是Atomic原子类。
核心属性介绍
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
static class Node<E> {
E item;
Node<E> next;
Node(E x) {
item = x;
}
}
// 指定队列的长度,如果不传值,默认为Integer.MAX
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();
// 省略了很多代码...
}
主要方法简介
1、入队操作
-
add(E): 如果满了,扔异常,数据丢弃
-
offer(E): 入队成功返回true,入队失败返回false,数据被丢弃
-
put(E): 入队失败线程挂起,直到入队成功
-
offer(E, time, unit): 入队失败线程等待指定时间返回false,数据丢弃
2、出队操作
-
remove():出队失败抛出异常
-
poll():出队失败返回null
-
take():出队失败一直挂起,直到有元素出队
-
poll(time, unit):出队失败等待指定时间后返回null
源码解析
add(E)
public boolean add(E e) {
// 直接调用offer进行处理,如果offer返回了false(队列满了),抛异常 IllegalStateException
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
offer(E)
public boolean offer(E e) {
// 判空
if (e == null) throw new NullPointerException();
// 获取当前队列元素个数
final AtomicInteger count = this.count;
// 队列满直接返回false
if (count.get() == capacity)
return false;
int c = -1;
// 封装Node
Node<E> node = new Node<E>(e);
// 获取入队锁
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
// 如果队列不满,直接入队操作,并且count+1
if (count.get() < capacity) {
enqueue(node);
c = count.getAndIncrement();
// 队列入队之后未满,则唤醒入队被挂起的线程
if (c + 1 < capacity)
notFull.signal();
}
} finally {
// 释放入队锁
putLock.unlock();
}
// c == 0 说明添加数据之前,队列是空的,唤醒可能阻塞的出队线程
if (c == 0)
signalNotEmpty();
return c >= 0;
}
private void enqueue(Node<E> node) {
// 加到队尾
last = last.next = node;
}
offer(E, time, unit)
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 {
// 队列满了,等待指定时间之后返回false
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();
}
// c == 0 说明添加数据之前,队列是空的,唤醒可能阻塞的出队线程
if (c == 0)
signalNotEmpty();
return true;
}
put(E)
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();
}
// c == 0 说明添加数据之前,队列是空的,唤醒可能阻塞的出队线程
if (c == 0)
signalNotEmpty();
}
remove()
public E remove() {
// 直接调用poll,如果返回null,则抛异常 NoSuchElementException
E x = poll();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
poll()
public E poll() {
// 如果队列count==0,则返回null
final AtomicInteger count = this.count;
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;
}
private E dequeue() {
// 队首出队操作
Node<E> h = head;
Node<E> first = h.next;
h.next = h; // 有利于GC
head = first;
E x = first.item;
first.item = null; // 有利于GC
return x;
}
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();
// 出队之后,如果队列还是不为空,则唤醒其他阻塞的出队线程
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
// 释放锁
takeLock.unlock();
}
// 如果本次操作之前队列满了,则唤醒入队阻塞的线程
if (c == capacity)
signalNotFull();
return x;
}
poll(time, unit)
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;
}