Java并发进阶：阻塞队列ArrayBlockingQueue源码解析

2401_84093973

于 2024-05-03 05:54:00 发布

阅读量1k

点赞数 17

分类专栏：程序员文章标签： java 面试算法

本文链接：https://blog.csdn.net/2401_84093973/article/details/138407667

版权

程序员专栏收录该内容

266 篇文章 0 订阅

订阅专栏

本文详细解析了一线大厂Java面试中关于ArrayBlockingQueue的构造器使用、公平性策略，以及入队、出队等核心操作的原理，包括阻塞队列的公平竞争策略和异常处理。同时讨论了自学与报班的学习方式及其优缺点。

摘要由CSDN通过智能技术生成

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！
构造器

===

使用ArrayBlockingQueue的时候，必须指定一个capacity阻塞队列的容量。可以传入可选的fair值，以采取不同公平性策略，默认使用非公平的策略。另外，可以传入集合对象，直接构造阻塞队列。

// 必须指定容量，默认采用非公平策略

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); // 初始化lock

notEmpty = lock.newCondition(); // 初始化条件变量notEmpty

notFull = lock.newCondition(); // 初始化条件变量notFull

}

// 另外，可指定传入集合直接构造

public ArrayBlockingQueue(int capacity, boolean fair,

Collection<? extends E> c) {

this(capacity, fair);

// 加锁只是为了可见性，而不是为了互斥特性

final ReentrantLock lock = this.lock;

lock.lock(); // Lock only for visibility, not mutual exclusion

try {

int i = 0;

try {

for (E e : c) { // 遍历赋值

checkNotNull(e);

items[i++] = e;

}

} catch (ArrayIndexOutOfBoundsException ex) {

throw new IllegalArgumentException();

}

count = i;

putIndex = (i == capacity) ? 0 : i;

} finally {

lock.unlock();

}

出队和入队操作

=======

队列的操作最核心的部分莫过于入队和出队了，后面分析的方法基本上都基于这两个工具方法。

入队enqueue

=========

private void enqueue(E x) {

// assert lock.getHoldCount() == 1;

// assert items[putIndex] == null;

final Object[] items = this.items;

// 把元素x放入数组

items[putIndex] = x;

// 下一个元素应该存放的下标位置

if (++putIndex == items.length)

putIndex = 0;

count++;

// 激活notEmpty的条件队列因调用take操作而被阻塞的一个线程

notEmpty.signal();

}

将元素x置入数组中。
计算下一个元素应该存放的下标位置。
元素个数器递增，这里count前加了锁，值都是从主内存中获取，不会存在内存不可见问题，并且更新也会直接刷新回主内存中。
最后激活notEmpty的条件队列因调用take操作而被阻塞的一个线程。

出队dequeue

=========

private E dequeue() {

// assert lock.getHoldCount() == 1;

// assert items[takeIndex] != null;

final Object[] items = this.items;

@SuppressWarnings(“unchecked”)

// 获取元素

E x = (E) items[takeIndex];

// 置null

items[takeIndex] = null;

// 重新设置对头下标

if (++takeIndex == items.length)

takeIndex = 0;

// 更新元素计数器

count–;

// 更新迭代器中的元素数据，itrs只用在使用迭代器的时候才实例化哦

if (itrs != null)

itrs.elementDequeued();

// 激活notFull的条件队列因调用put操作而被阻塞的一个线程

notFull.signal();

return x;

}

获取元素，并将当前位置置null。
重新设置队头下标。
元素计数器递减。
更新迭代器中的元素数据，itrs默认情况下都是为null的，只有使用迭代器的时候才会实例化Itrs。
激活notFull的条件队列因调用put操作而被阻塞的一个线程。

阻塞式操作

=====

E take() 阻塞式获取

==============

take操作将会获取当前队列头部元素并移除，如果队列为空则阻塞当前线程直到队列不为空，退出阻塞时返回获取的元素。

那，线程阻塞至何时如何知道呢，其实当前线程将会因notEmpty.await()被包装成等待节点置入notEmpty的条件队列中，一旦enqueue操作成功触发，也就是入队成功，将会执行notEmpty.signal()唤醒条件队列中等待的线程，被转移到AQS队列中参与锁的争夺。

如果线程在阻塞时被其他线程设置了中断标志，则抛出InterruptedException异常并返回。

public E take() throws InterruptedException {

final ReentrantLock lock = this.lock;

// 可响应中断式地获取锁

lock.lockInterruptibly();

try {

// 如果队列为空，则将当前线程包装为等待节点置入notEmpty的条件队列中

while (count == 0)

notEmpty.await();

// 非空，则执行入队操作，入队时唤醒notFull的条件队列中的第一个线程

return dequeue();

} finally {

lock.unlock();

}

void put(E e) 阻塞式插入

===================

put操作将向队尾插入元素，如果队列未满则插入，如果队列已满，则阻塞当前线程直到队列不满。

如果线程在阻塞时被其他线程设置了中断标志，则抛出InterruptedException异常并返回。

public void put(E e) throws InterruptedException {

checkNotNull(e);

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

// 如果队列满，则将当前线程包装为等待节点置入notFull的条件队列中

while (count == items.length)

notFull.await();

// 非满，则执行入队操作，入队时唤醒notEmpty的条件队列中的第一个线程

enqueue(e);

} finally {

lock.unlock();

}

E poll(timeout, unit) 阻塞式超时获取

=============================

在take阻塞式获取方法的基础上额外增加超时功能，传入一个timeout，获取不到而阻塞的时候，如果时间到了，即使还获取不到，也只能立即返回null。

public E poll(long timeout, TimeUnit unit) throws InterruptedException {

long nanos = unit.toNanos(timeout);

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

while (count == 0) {

// 队列仍为空，但是时间到了，必须返回了

if (nanos <= 0)

return null;

// 在条件队列里等着，但是需要更新时间

nanos = notEmpty.awaitNanos(nanos);

}

return dequeue();

} finally {

lock.unlock();

}

boolean offer(e, timeout, unit) 阻塞式超时插入

=======================================

在put阻塞式插入方法的基础上额外增加超时功能，传入一个timeout，获取不到而阻塞的时候，如果时间到了，即使还获取不到，也只能立即返回null。

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

throws InterruptedException {

checkNotNull(e);

long nanos = unit.toNanos(timeout);

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

while (count == items.length) {

if (nanos <= 0)

return false;

nanos = notFull.awaitNanos(nanos);

}

enqueue(e);

return true;

} finally {

lock.unlock();

}

其他常规操作

======

boolean offer(E e)

==================

offer(E e)是非阻塞的方法，向队尾插入一个元素，如果队列未满，则插入成功并返回true；如果队列已满则丢弃当前元素，并返回false。

public boolean offer(E e) {

checkNotNull(e); // 如果插入元素为null，则抛出NullPointerException异常

// 获取独占锁

final ReentrantLock lock = this.lock;

lock.lock();

try {

// 如果队列满，则返回false

if (count == items.length)

return false;

else {

// 否则则入队

enqueue(e);

return true;

}

} finally {

lock.unlock();

}

E poll()

========

从队列头部获取并移除第一个元素，如果队列为空则返回null。

public E poll() {

final ReentrantLock lock = this.lock;

lock.lock();

try {

// 如果为空，返回null，否则执行出队操作

return (count == 0) ? null : dequeue();

} finally {

lock.unlock();

}

Boolean remove(Object o)

========================

移除队列中与元素o相等【指的是equals方法判定相同】的元素，移除成功返回true，如果队列为空或没有匹配元素，则返回false。

最后

为什么我不完全主张自学？
①平台上的大牛基本上都有很多年的工作经验了，你有没有想过之前行业的门槛是什么样的，现在行业门槛是什么样的？以前企业对于程序员能力要求没有这么高，甚至十多年前你只要会写个“Hello World”，你都可以入门这个行业，所以以前要入门是完全可以入门的。
②现在也有一些优秀的年轻大牛，他们或许也是自学成才，但是他们一定是具备优秀的学习能力，优秀的自我管理能力（时间管理，静心坚持等方面）以及善于发现问题并总结问题。
如果说你认为你的目标十分明确，能做到第②点所说的几个点，以目前的市场来看，你才真正的适合去自学。

除此之外，对于绝大部分人来说，报班一定是最好的一种快速成长的方式。但是有个问题，现在市场上的培训机构质量参差不齐，如果你没有找准一个好的培训班，完全是浪费精力，时间以及金钱，这个需要自己去甄别选择。

我个人建议线上比线下的性价比更高，线下培训价格基本上没2W是下不来的，线上教育现在比较成熟了，此次疫情期间，学生基本上都感受过线上的学习模式。相比线下而言，线上的优势以我的了解主要是以下几个方面：
①价格：线上的价格基本上是线下的一半；
②老师：相对而言线上教育的师资力量比线下更强大也更加丰富，资源更好协调；
③时间：学习时间相对而言更自由，不用裸辞学习，适合边学边工作，降低生活压力；
④课程：从课程内容来说，确实要比线下讲的更加深入。

应该学哪些技术才能达到企业的要求？（下图总结）