Java中的阻塞队列LinkedBlockingQueue

目录 1.LinkedBlockingQueue介绍     1.1BlockingQueue接口     1.2LinkedBlockingQueue     1.3LinkedBlockingQueue原理与数据结构 2.LinkedBlockingQueue源码分析     2.1创建     2.2put方法     2.3take方法

1.LinkedBlockingQueue介绍

Java中的阻塞队列LinkedBlockingQueue

1.1BlockingQueue接口

同ArrayBlockingQueue一样,LinkedBlockingQueue同样实现了BlockingQueue接口。

1.2LinkedBlockingQueue

LinkedBlockingQueue

LinkedBlockingQueue是一个单向链表实现的阻塞队列。

LinkedBlockingQueue可以在创建时指定容量大小,防止队列过度膨胀。如果未指定队列容量,默认容量大小为Integer.MAX_VALUE。

1.3LinkedBlockingQueue原理与数据结构

Java中的阻塞队列LinkedBlockingQueue

说明:

(01) head是链表的表头。取出数据时,都是从表头head处取出,出队。
(02) last是链表的表尾。新增数据时,都是从表尾last处插入,入队。
(03) count是链表的实际大小,即当前链表中包含的节点个数。
(04) capacity是列表的容量,它是在创建链表时指定的。
(05) putLock是插入锁,takeLock是取出锁;notEmpty是“非空条件”,notFull是“未满条件”。通过它们对链表进行并发控制。

 LinkedBlockingQueue在实现“多线程对竞争资源的互斥访问”时,对于“插入”和“取出(删除)”操作分别使用了不同的锁。对于插入操作,通过“插入锁putLock”进行同步;对于取出操作,通过“取出锁takeLock”进行同步。

Java中的阻塞队列LinkedBlockingQueue

 

2.LinkedBlockingQueue源码分析

2.1创建

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}
//队列容量, 如果创建时未指定,默认为Integer.MAX_VALUE
private final int capacity;
//队列中元素的数量
private final AtomicInteger count = new AtomicInteger();
//链表的头部(队头)
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; }
}
 

2.2 put方法

//put方法:若队列满,wait直到队列有空闲
public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    // Note: convention in all put/take/etc is to preset local var
    // holding count negative to indicate failure unless set.
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
  //获得锁
    putLock.lockInterruptibly();
    try {
    //如果队列满,当前(生产者)线程在notFull上阻塞等待
        while (count.get() == capacity) {
            notFull.await();
        }
    //元素进队
        enqueue(node);
    //将“队列中元素数量“+1,并返回“原有的元素数量”
        c = count.getAndIncrement();
    //如果元素进队之后,队列仍然未满,唤醒等待在notFull上的(生产者)线程
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
    //释放锁
        putLock.unlock();
    }
  //如果队列中原有的元素数量为0,则在元素进队后,唤醒等待在notEmpty上的(消费者)线程
    if (c == 0)
        signalNotEmpty();
}
​
private void enqueue(Node<E> node) {
    // assert putLock.isHeldByCurrentThread();
    // assert last.next == null;
    last = last.next = node;
}
private void signalNotEmpty() {
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
}

2.3 take方法

//take方法:若队列空,wait直到队列非空
public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
  //获得锁
    takeLock.lockInterruptibly();
    try {
    //如果队列为空,当前(消费者)线程在notEmpty上阻塞等待
        while (count.get() == 0) {
            notEmpty.await();
        }
    //元素出队
        x = dequeue();
    //将“队列中元素数量“-1,并返回“原有的元素数量”
        c = count.getAndDecrement();
        //如果元素出队之后,队列仍有剩余元素,唤醒等待在notEmpty上的(消费者)线程
        if (c > 1)
            notEmpty.signal();
    } finally {
    //释放锁
        takeLock.unlock();
    }
  //如果原来队列是满的,则在元素出队后,唤醒等待在notFull上的(生产者)线程
    if (c == capacity)
        signalNotFull();
    return x;
}
​
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;
}
private void signalNotFull() {
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        notFull.signal();
    } finally {
        putLock.unlock();
    }
}
 
上一篇:[从源码学设计]蚂蚁金服SOFARegistry 之 自动调节间隔周期性任务


下一篇:并发编程 - 阻塞队列(二) - LinkedBlockingQueue