并发队列
并发包下面的并发容器中,ConcurrentLinkedQueue 这种 Concurrent 类型和的集合才真正代表并发。
- Concurrent 类型基于 lock-free ,常见的多线程访问场景,一般可以提供高吞吐量。
- LinkedBlockingQueue 内部基于锁实现,提供了BlockingQueue等特性方法。
java.util.concurrent 包并发容器分类
- Concurrent
- CopyOnWrite
- Blocking
Concurrent 类型集合
- Concurrent 类型没有类似 CopyOnWrite 之类容器相对较重的修改开销。
- Concurrent 往往提供了较低的遍历一致性,可以理解所谓的弱一致性,例如,当迭代器遍历时,如果容器发生修改,迭代器仍然可以继续遍历。
- 弱一致性的另外一个体现是, size 等操作准确性有限的,未必是100%准确。
- 读取的性能具有一定的不确定性
Java 集合中有个线程不安全的队列 LinkedList 是个 Deque。
ConcurrentLinkedDeque 和 LinkedBlockingQueue 区别
能够理解 ConcurrentLinkedQueue 和 LinkedBlockingQueue 的主要区别。
在常规队列操作基础上, Blocking意味着提供了特定的等待性操作。
阻塞队列 LinkedBlockingQueue
适用阻塞队列的好处,多线程操作共同的队列时不需要额外的同步。
- void put(E e): 在队尾插入元素,方法在队列满的时候会阻塞直到有队列成员被消费
- boolean offer(E e): 在队尾插入元素,方法在队列满的时候不会阻塞,直接返回 false
- E take(): 取出并删除队列中的首元素,如果队列为空,会阻塞,直到有队列成员被放进来
- E poll(): 取出并删除队列中的首元素,如果队列为空,则返回 null,不进行阻塞
- E peek(): 取出第一个元素但是不删除它,没有就返回 null
非阻塞队列 ConcurrentLinkedQueue
允许多线程访问一个共同集合,可以使用 ConcurrentLinedQueue
Queue 中元素按 FIFO 原则进行排序。采用CAS 操作,来保证元素的一致性。
- boolean offer(E e): 在队尾插入元素,不进行阻塞
- E poll(): 取出并删除队列中的首元素,不进行阻塞
- E peek(): 取出第一个元素但是不删除它,不进行阻塞
ConcurrentLinkedDeque 和 LinkedBlockingDeque。 Deque 的侧重点是支持对队列的头尾都信息插入和删除:
- 尾部插入时需要的addLast(e)、 offerLast(e)。
- 尾部删除所需要的removeLast()、 pollLast()。
阻塞队列 BlockingQueue 分类
- ArrayBlockingQueue
ArrayBlockingQueue是最典型的的有界队列,其内部以final的数组保存数据,数组的大小就决定了队列的边界,所以我们在创建ArrayBlockingQueue时,都要指定容量,如:
public ArrayBlockingQueue(int capacity, boolean fair)
- LinkedBlockingQueue
其行为和内部代码都是基于有界的逻辑实现的,只不过如果我们没有在创建队列时就指定容量,那么其容量限制就自动被设置为Integer.MAX_VALUE,成为了无界队列。
- SynchronousQueue
每个删除操作都要等待插入操作,反之每个插入操作也都要等待删除动作。这个队列的容量是0。
-
PriorityBlockingQueue
是无边界的优先队列,虽然严格意义上来讲,其大小总归是要受系统资源影响。 -
DelayedQueue 和 LinkedTransferQueue
都是无边界队列,就是 put 操作永远不会发生其他 BlockingQueue 阻塞的情况。
LinkedBlockingQueue 实现原理
/** Lock held by take, poll, etc */
private fnal ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private fnal Condition notEmpty = takeLock.newCondition();
/** Lock held by put, ofer, etc */
private fnal ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private fnal Condition notFull = putLock.newCondition();
LinkedBlockingQueue 改进了锁操作的力度,头,尾操作使用不同的锁,在通用的场景下,他的吞吐量相对要更好一些。
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
while (count.get() == 0) {
notEmpty.await();
}
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
}
ArrayBlockingQueue take 实现原理
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return dequeue();
} finally {
lock.unlock();
}
}
队列的使用场景
队列的典型使用场景是 生产者 -消费者 场景。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ConsumerProducer {
public static final String EXIT_MSG = "Good bye!";
public static void main(String[] args) {
// 使用较小的队列,以更好地在输出中展示其影响
BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue);
new Thread(producer).start();
new Thread(consumer).start();
}
static class Producer implements Runnable {
private BlockingQueue<String> queue;
public Producer(BlockingQueue<String> q) {
this.queue = q;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(5L);
String msg = "Message" + i;
System.out.println("Produced new item: " + msg);
queue.put(msg);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
System.out.println("Time to say good bye!");
queue.put(EXIT_MSG);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class Consumer implements Runnable {
private BlockingQueue<String> queue;
public Consumer(BlockingQueue<String> q) {
this.queue = q;
}
@Override
public void run() {
try {
String msg;
while (!EXIT_MSG.equalsIgnoreCase((msg = queue.take()))) {
System.out.println("Consumed item: " + msg);
Thread.sleep(10L);
}
System.out.println("Got exit message, bye!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}