无界
一个链表两把锁两个条件
单向链表实现的阻塞队列
FIFO排序元素,新元素插入到队列的尾部,并且队列获取操作会获得位于队列头部的元素
吞吐量高于基于数组的队列
可选容量(防止过度膨胀),但如果不指定,则默认容量大小为Integer.MAX_VALUE
-
- LinkedBlockingQueue继承于AbstractQueue,它本质上是一个FIFO(先进先出)的队列。
-
- LinkedBlockingQueue实现了BlockingQueue接口,它支持多线程并发。当多线程竞争同一个资源时,某线程获取到该资源之后,其它线程需要阻塞等待。
-
- LinkedBlockingQueue是通过单链表实现的。
-
(01) head是链表的表头。取出数据时,都是从表头head处插入。
-
(02) last是链表的表尾。新增数据时,都是从表尾last处插入。
-
(03) count是链表的实际大小,即当前链表中包含的节点个数。
-
(04) capacity是列表的容量,它是在创建链表时指定的。
-
(05)putLock是插入锁,takeLock是取出锁;notEmpty是“非空条件”,notFull是“未满条件”。通过它们对链表进行并发控制。
LinkedBlockingQueue在实现“多线程对竞争资源的互斥访问”时,对于“插入”和“取出(删除)”操作分别使用了不同的锁。对于插入操作,通过“插入锁putLock”进行同步;对于取出操作,通过“取出锁takeLock”进行同步。 此外,插入锁putLock和“非满条件notFull”相关联,取出锁takeLock和“非空条件notEmpty”相关联。通过notFull和notEmpty更细腻的控制锁。
若某线程要取出数据时,队列正好为空,则该线程会执行notEmpty.await()进行等待,当其它某个线程向队列中插入数据之后,会调用notEmpty.signal()唤醒等待线程,此时线程在执行取操作前会后去takeLock,在取操作执行完毕再释放takeLock
当某线程要插入数据时,队列刚好为满,则线程会执行notFull.await()进行等待,当某个线程取出数据之后,会调用notFull.signal()唤醒等待线程,此时线程在执行插入操作之前,会获取putLock,在插入操作执行完毕之后才释放putLock
创建
public LinkedBlockingQueue (int capacity){
if(capacity<=0)
throw new IlleagalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
capacity是链式阻塞队列的容量
head和last是链式阻塞队列的首节点和尾节点
// 容量
private final int capacity;
// 当前数量
private final AtomicInteger count = new AtomicInteger(0);
private transient Node<E> head; // 链表的表头
private transient Node<E> last; // 链表的表尾
// 用于控制“删除元素”的互斥锁takeLock 和 锁对应的“非空条件”notEmpty
private final ReentrantLock takeLock = new ReentrantLock();
private final Condition notEmpty = takeLock.newCondition();
// 用于控制“添加元素”的互斥锁putLock 和 锁对应的“非满条件”notFull
private final ReentrantLock putLock = new ReentrantLock();
private final Condition notFull = putLock.newCondition();
节点定义
static class Node<E>{
E item;
Node<E> next;
Node(E x){
item = x;
}
}
添加
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
// 如果“队列已满”,则返回false,表示插入失败。
final AtomicInteger count = this.count;
if (count.get() == capacity)
return false;
int c = -1;
// 新建“节点e”
Node<E> node = new Node(e);
final ReentrantLock putLock = this.putLock;
// 获取“插入锁putLock”
putLock.lock();
try {
// 再次对“队列是不是满”的进行判断。
// 若“队列未满”,则插入节点。
if (count.get() < capacity) {
// 插入节点
enqueue(node);
// 将“当前节点数量”+1,并返回“原始的数量”
c = count.getAndIncrement();
// 如果在插入元素之后,队列仍然未满,则唤醒notFull上的等待线程。
if (c + 1 < capacity)
notFull.signal();
}
} finally {
// 释放“插入锁putLock”
putLock.unlock();
}
// 如果在插入节点前,队列为空;则插入节点后,唤醒notEmpty上的等待线程
if (c == 0)
signalNotEmpty();
return c >= 0;
}
enqueue()
在队尾加入节点
private void enqueue(Node<E> node){
last = last.next = node;
}
signalNotEmpty()
private void signalNotEmpty(){
final ReentrantLock takeLock = this.lock();
takeLock.lock();
try {
notEmpty.signal();
} finally {
takeLock.unlock();
}
}
取出
public E take() throws InterruptedException{
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
// 获取“取出锁”,若当前线程是中断状态,则抛出InterruptedException异常
takeLock.lockInterruptibly();
try {
// 若“队列为空”,则一直等待。
while (count.get() == 0) {
notEmpty.await();
}
// 取出元素
x = dequeue();
// 取出元素之后,将“节点数量”-1;并返回“原始的节点数量”。
c = count.getAndDecrement();
if (c > 1)
} finally {
notEmpty.signal();
// 释放“取出锁”
takeLock.unlock();
}
// 如果在“取出元素之前”,队列是满的;则在取出元素之后,唤醒notFull上的等待线程。
if (c == capacity)
signalNotFull();
return x;
}
dequeue()
private E dequeue() {
Node<E> h = head;
//first节点中才存储了队列中第一个元素的数据
Node<E> first = h.next;
h.next = h; // help GC 即将第一个节点置为头结点
//设置新的head值,相当于删除了first节点,因为head节点本身不存储数据
head = first;
E x = first.item;
first.item = null;
return x;
}
singalNotFull()
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
notFull.signal();
} finally {
putLock.unlock();
}
}
三种入队对比
offer 如果队列没满,立即返回true;如果队列满了,立即返回false
put 如果队列满了,一直阻塞,直到队列不满或者线程被中断
offer(E e ,long timeout ,TimeUnit unit) 在队尾插入一个元素,如果队列已满则进入等待;直到出现以下三种情况
1 被唤醒
2 等待时间超时
3 当前线程被中断
三种出队对比
poll 如果没有元素,直接返回null;如果有元素,出队
take 如果队列空了,一直阻塞,直到队列不为空或者线程被中断
poll(long timeout,TimeUnit unit) 如果队列不为空出队;如果队列已经为空并且已经超时,返回 null;
如果队列已空且未超时,则进入等待,直到出现以下三种情况
1 被唤醒
2 等待时间超时
3 当前线程被中断
ArrayBlockingQueue与LinkedBlockingQueue对比
ArrayBlockingQueue:
- 一个对象数组+一把锁+两个条件
- 入队与出队都用同一把锁
- 在只有入队高并发或出队高并发的情况下,因为操作数组,且不需要扩容,性能很高
- 采用了数组,必须指定大小,即容量有限
LinkedBlockingQueue:
- 一个单向链表+两把锁+两个条件
- 两把锁,一把用于入队,一把用于出队,有效的避免了入队与出队时使用一把锁带来的竞争。
- 在入队与出队都高并发的情况下,性能比ArrayBlockingQueue高很多
- 采用了链表,最大容量为整数最大值,可看做容量无限