Java并发编程(四) - 原子类及阻塞队列
Java并发编程(四) - 原子类及阻塞队列
1. 概述
这里主要讲Java并发包中原子类以及阻塞队列
2. 阻塞队列
2.1 阻塞队列的概念
阻塞队列是支持阻塞插入(队列满时，队列会阻塞插入元素的线程)以及阻塞移除(队列为空时，获取元素的队列会被阻塞)的队列。阻塞队列常用于生产者/消费者存放/获取元素的容器。
2.2 阻塞队列的插入与移除方式
| 方法/处理方式 | 抛出异常 | 返回特殊值 | 一直阻塞 | 超时抛出 |
|---|---|---|---|---|
| 插入方法 | add(e) | offer(e) | put(e) | offer(e, time, unit) |
| 移除方法 | remove() | poll() | take() | poll(time, unit) |
| 检查方法 | element | peek() | 不可用 | 不可用 |
注：如果是无界阻塞队列，队列不可能出现满的情况，所以使用put或offer不会阻塞，offer永远放回true。
2.3 Java中的阻塞队列
| 队列名 | 描述 |
|---|---|
| ArrayBlockingQueue | 由数组结构组成的有界阻塞队列，可选公平策略，默认非公平队列 |
| LinkedBlockingQueue | 由链表结构组成的有界阻塞队列，队列最大长度为Integer.MAX_VALUE(可以说无界) |
| PriorityBlockingQueue | 支持优先级排序的无界阻塞队列，元素必须实现Compareable接口或者构造时传入Comparator |
| DelayQueue | 支持延时获取元素的无界阻塞队列，元素必须实现Delayed接口 |
| SynchrinousQueue | 不存储元素的阻塞队列，也就是说每个put操作必须等待一个take操作 |
注：以上阻塞队列还没有写完，具体可见Java API。
2.4 阻塞队列的实现机制
其实之前的Java并发编程(三)已经讲过了，阻塞队列的实现有Lock+Condition的等待/通知机制来实现的，具体可见ArrayBlockingQueue的源码(JDK 1.8)如下所示，注：源码省略了一些内容：
public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
/** The queued items */
final Object[] items;
/** items index for next take, poll, peek or remove */
int takeIndex;
/** items index for next put, offer, or add */
int putIndex;
/** Number of elements in the queue */
int count;
/** Main lock guarding all access */
final ReentrantLock lock;
/** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;
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();
}
/**
* put操作
*/
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
// 当队列中元素满了，阻塞插入元素的线程
while (count == items.length)
notFull.await();
// 插入元素到队列中
enqueue(e);
} finally {
lock.unlock();
}
}
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
// 通知获取等待队列中的线程有元素可获取
notEmpty.signal();
}
/**
* take操作
*/
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
// 当队列中元素为空，阻塞获取元素的线程
while (count == 0)
notEmpty.await();
// 从队列中移除一个元素
return dequeue();
} finally {
lock.unlock();
}
}
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
// 通知插入等待队列中的线程有空位可供插入元素
notFull.signal();
return x;
}
}
阻塞/唤醒线程是通过Condition中的await()与signal()实现的，而锁依赖于AQS实现的，具体可以看AQS中的ConditionObject的await()与signal()方法。而AQS中的阻塞/唤醒线程使用了LockSupport类中park()与unPark()方法，再进一步就是调用本地方法进行阻塞/唤醒线程。
3. Java中的原子类
3.1 原子类的概述
原子类具有内存可见性以及原子性的特征，我们知道volatile变量具有内存可见性以及单个读写操作的原子性，但对于复杂操作不具有原子性。然后，通过引进CAS操作来实现原子性。所以原子类是由volatile+CAS来共同实现的。
3.2 原子类的实现
原子类是由volatile+CAS来实现的，具体可见AtomicInteger的源码(JDK 1.8)如下，注：源码有删减
public class AtomicInteger extends Number implements java.io.Serializable {
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}
public AtomicInteger(int initialValue) {
value = initialValue;
}
public final int get() {
return value;
}
/**
* 这里使用到了CAS操作，通过本地方法进行原子更新
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
}
4. References
《Java并发编程的艺术》
