本文通过用户注册积分案例，展示了如何使用ArrayBlockingQueue优化代码执行逻辑，减少耦合并提高性能。介绍了Java中多种阻塞队列的特点及操作方法。
生产者消费者的实际使用
相信大家都有使用过分布式消息队列，比如 ActiveMQ、 kafka、RabbitMQ 等等，消息队列的是有可以使得程序之间实现解耦，提升程序响应的效率。 如果我们把多线程环境比作是分布式的话，那么线程与线程之间是不是也可以使用这种消息队列的方式进行数据通信和解耦呢?
阻塞队列的使用案例
注册成功后增加积分
假如我们模拟一个场景，就是用户注册的时候，在注册成功以后发放积分。这个场景在一般来说，我们会这么去实现
但是实际上，我们需要考虑两个问题
- 性能，在注册这个环节里面，假如添加用户需要花费 1 秒钟，增加积分需要花费 1 秒钟，那么整个注册结果的返回就可能需要大于 2 秒，虽然影响不是很大，但是在量比较大的时候，我们也需要做一些优化
- 耦合，添加用户和增加积分，可以认为是两个领域，也就是说，增加积分并不是注册必须要具备的功能，但是一旦增加积分这个逻辑出现异常，就会导致注册失败。这种耦合在程序设计的时候是一定要规避的
因此我们可以通过异步的方式来实现
改造前的代码逻辑
public class UserService {
public boolean register() {
User user = new User();
user.setName("Mic");
addUser(user);
sendPoints(user);
return true;
}
private void addUser(User user) {
System.out.println("添加用户:" + user);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void sendPoints(User user) {
System.out.println(" 发送积分给指定用户:" + user);
try {
Thread.sleep(1000);
} catch (
InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new UserService().register();
}
}
改造后的代码：
public class UserService {
private final ExecutorService single = Executors.newSingleThreadExecutor();
private volatile boolean isRunning = true;
ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(10);
{
init();
}
public void init() {
single.execute(() -> {
while (isRunning) {
try {
User user = (User) arrayBlockingQueue.take();//阻塞的方式获取队列中的数据
sendPoints(user);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
public boolean register() {
User user = new User();
user.setName("Mic");
addUser(user);
arrayBlockingQueue.add(user);//添加到异步队列
return true;
}
public static void main(String[] args) {
new UserService().register();
}
private void addUser(User user) {
System.out.println("添加用户:" + user);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void sendPoints(User user) {
System.out.println(" 发送积分给指定用户:" + user);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
在这个案例中，我们使用了 ArrayBlockingQueue 基于数组的阻塞队列，来优化代码的执行逻辑。
J.U.C 中的阻塞队列
在JAVA8中 J.U.C 提供了 七 种阻塞队列
| 名称 | 说明 |
|---|---|
| ArrayBlockingQueue | 数组实现的有界阻塞队列, 此队列按照先进先出(FIFO)的原则 对元素进行排序。 |
| LinkedBlockingQueue | 链表实现的有界阻塞队列, 此队列的默认和最大长度为 Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行 排序 |
| PriorityBlockingQueue | 支持优先级排序的无界阻塞队列, 默认情况下元素采取自然顺序，升序排列。也可以自定义类实现 compareTo()方法来指定元素排序规则，或者初始化 PriorityBlockingQueue 时，指定构造参数 Comparator 来对元素进行排序。 |
| DelayQueue | 优先级队列实现的无界阻塞队列 |
| SynchronousQueue | 不存储元素的阻塞队列, 每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素。 |
| LinkedTransferQueue | 链表实现的无界阻塞队列 |
| LinkedBlockingDeque | 链表实现的双向阻塞队列 |
阻塞队列的操作方法
在阻塞队列中，提供了四种处理方式
- 插入操作
add(e) :添加元素到队列中，如果队列满了，继续插入元素会报错，IllegalStateException。
offer(e) : 添加元素到队列，同时会返回元素是否插入成功的状态，如果成功则返回 true
put(e) :当阻塞队列满了以后，生产者继续通过 put 添加元素，队列会一直阻塞生产者线程，直到队列可用
offer(e,time,unit) :当阻塞队列满了以后继续添加元素， 生产者线程会被阻塞指定时间，如果超时，则线程直接退出 - 移除操作
remove():当队列为空时，调用 remove 会返回 false， 如果元素移除成功，则返回 true
poll(): 当队列中存在元素，则从队列中取出一个元素， 如果队列为空，则直接返回 null
take():基于阻塞的方式获取队列中的元素，如果队列为空，则 take 方法会一直阻塞，直到队列中有新的数据可以消费
poll(time,unit):带超时机制的获取数据，如果队列为空， 则会等待指定的时间再去获取元素返回
ArrayBlockingQueue 原理分析
构造方法
ArrayBlockingQueue 有三个构造方法
// 1. capacity: 表示数组的长度，也就是队列的长度
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
// 2. fair:表示是否为公平的阻塞队列，默认情况下构造的是非公平的阻塞队列。
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);//重入锁，出队和入队持有这一把锁
notEmpty = lock.newCondition();//初始化非空等待队列
notFull = lock.newCondition();//初始化非满等待队列
}
// 3. 增加了一个集合，作为初始化数据
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();
}
}
add 方法
以 add 方法作为入口，在 add 方法中会调用父类的 add 方法，也就是 AbstractQueue.如果看源码看得比较多的话，一般这种写法都是调用父类的模版方法来解决通用性问题
ArrayBlockingQueue.java
public boolean add(E e) {
return super.add(e);
}
AbstractQueue.java
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
从父类的 add 方法可以看到，这里做了一个队列是否满了的判断，如果队列满了直接抛出一个异常
offer 方法
add 方法最终还是调用 offer 方法来添加数据，返回一个添加成功或者失败的布尔值。
这段代码做了几个事情
- 判断添加的数据是否为空
- 添加重入锁
- 判断队列长度，如果队列长度等于数组长度，表示满了直接返回 false
- 否则，直接调用 enqueue 将元素添加到队列中
public boolean offer(E e) {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count == items.length)
return false;
else {
insert(e);
return true;
}
} finally {
lock.unlock();
}
}
enqueue 方法
这个是最核心的逻辑，方法内部通过 putIndex 索引直接将元素添加到数组 items
jdk1.8 才改名叫enqueue
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;//通过putIndex对数据赋值
if (++putIndex == items.length)
// 当putIndex 等于数组长度时，将 putIndex 重置为 0
putIndex = 0;
count++;//记录队列元素的个数
// 唤醒处于等待状态下的线程，表示当前队列中的元素不为空,如果存在消费者线程阻塞，就可以开始取出元素
notEmpty.signal();
}
这里大家肯定会有一个疑问，putIndex 为什么会在等于数组长度的时候重新设置为 0。因为 ArrayBlockingQueue 是一个 FIFO 的队列，队列添加元素时，是从队尾获取 putIndex 来存储元素，当 putIndex 等于数组长度时，下次就需要从数组头部开始添加了。
put 方法
put 方法和 add 方法功能一样，差异是 put 方法如果队列满了，会阻塞。看一下它的实现逻辑
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
/* 这个方法也是获得锁，但是和lock的区别是，这个方法优先允许在等待时由其他线程调用等待线程的
interrupt方法来中断等待直接返回。而lock方法是尝试获得锁成功后才响应中断 */
lock.lockInterruptibly();
try {
while (count == items.length)
//队列满了的情况下，当前线程将会被 notFull 条件对象挂起加到等待队列中
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
}
take 方法
take 方法是一种阻塞获取队列中元素的方法它的实现原理很简单，有就获取没有就阻塞，注意这个阻塞是可以中断的，如果队列没有数据那么就加入 notEmpty 条件队列等待(有数据就直接取走，方法结束)，如果有新的 put 线程添加了数据，那么 put 操作将会唤醒 take 线程， 执行 take 操作。
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
//如果队列为空的情况下，直接通过 await 方法阻塞
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
如果队列中添加了元素，那么这个时候，会在 enqueue 中调用 notempty.signal 唤醒 take 线程来获得元素
dequeue 方法
这个是出队列的方法，主要是删除队列头部的元素并发返回给客户端takeIndex，用来记录拿数据的索引值
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];//默认获取0位置的元素
items[takeIndex] = null;//将该位置的元素设置为空
if (++takeIndex == items.length)//这里的作用也是一样，如果拿到数组的最大值，那么重置为 0，继续从头部 位置开始获取数据
takeIndex = 0;
count--;//记录元素个数递减
if (itrs != null)
itrs.elementDequeued();//同时更新迭代器中的元素数据
notFull.signal();//触发因为队列满了以后导致的被阻塞的线程
return x;
}
itrs.elementDequeued();
ArrayBlockingQueue 中，实现了迭代器的功能，也就是可以通过迭代器来遍历阻塞队列中的元素。所以 itrs.elementDequeued() 是用来更新迭代器中的元素数据的
remove 方法
remove 方法是移除一个指定元素。看看它的实现代码
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 {
if (o.equals(items[i])) {
//从 takeIndex 下标开始，找到要被删除的元素
removeAt(i);//移除指定元素
return true;//返回执行结果
}
//当前删除索引执行加 1 后判断是否与数组长度相等
//若为 true，说明索引已到数组尽头，将 i 设置为 0
if (++i == items.length)
i = 0;
} while (i != putIndex);//继续查找，直到找到最后一个元素
}
return false;
} finally {
lock.unlock();
}
}
扫一扫
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
