2024年Java并发进阶：阻塞队列ArrayBlockingQueue源码解析，springcloud原理面试题

文末

我将这三次阿里面试的题目全部分专题整理出来，并附带上详细的答案解析，生成了一份PDF文档

• 第一个要分享给大家的就是算法和数据结构

• 第二个就是数据库的高频知识点与性能优化

• 第三个则是并发编程（72个知识点学习）

• 最后一个是各大JAVA架构专题的面试点+解析+我的一些学习的书籍资料

还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

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();

}

1. 将元素x置入数组中。

2. 计算下一个元素应该存放的下标位置。

3. 元素个数器递增，这里count前加了锁，值都是从主内存中获取，不会存在内存不可见问题，并且更新也会直接刷新回主内存中。

4. 最后激活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;

}

1. 获取元素，并将当前位置置null。

2. 重新设置队头下标。

3. 元素计数器递减。

4. 更新迭代器中的元素数据，itrs默认情况下都是为null的，只有使用迭代器的时候才会实例化Itrs。

5. 激活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。

public boolean remove(Object o) {

if (o == null) return false;

final Object[] items = this.items;

final ReentrantLock lock = this.lock;

lock.lock();

try {

if (count > 0) {

// 获取当前队尾位置

final int putIndex = this.putIndex;

// 从队头开始遍历

int i = takeIndex;

do {

// 找到了对应的元素的位置，removeAt删除该位置的元素

if (o.equals(items[i])) {

removeAt(i);

return true;

}

if (++i == items.length)

i = 0;

} while (i != putIndex);

总结

三个工作日收到了offer，头条面试体验还是很棒的，这次的头条面试好像每面技术都问了我算法，然后就是中间件、MySQL、Redis、Kafka、网络等等。

• 第一个是算法

关于算法，我觉得最好的是刷题，作死的刷的，多做多练习，加上自己的理解，还是比较容易拿下的。

而且，我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍，尤其是这本

《算法刷题LeetCode中文版》总共有15个章节：编程技巧、线性表、字符串、栈和队列、树、排序、查找、暴力枚举法、广度优先搜索、深度优先搜索、分治法、贪心法、动态规划、图、细节实现题

《算法的乐趣》共有23个章节：

• 第二个是Redis、MySQL、kafka（给大家看下我都有哪些复习笔记）

基本上都是面试真题解析、笔记和学习大纲图，感觉复习也就需要这些吧（个人意见）

• 第三个是网络（给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

[外链图片转存中…(img-f229IeP3-1714845603472)]

[外链图片转存中…(img-S004M4kO-1714845603473)]

• 第二个是Redis、MySQL、kafka（给大家看下我都有哪些复习笔记）

基本上都是面试真题解析、笔记和学习大纲图，感觉复习也就需要这些吧（个人意见）

[外链图片转存中…(img-0hFmIshz-1714845603473)]

• 第三个是网络（给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）

[外链图片转存中…(img-hnTMuVBV-1714845603473)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取