并发队列与 ABA 问题
在并发系统中,队列是一种非常重要的数据结构,它可以用于实现生产者 - 消费者模型,保证数据的有序处理。本文将详细介绍并发队列的相关知识,包括不同类型的队列及其实现原理。
1. 池的概念
在并发系统中,池(Pool)是一种常见的数据结构。它与集合(Set)类似,但有两个主要区别:一是池不一定提供
contains()
方法来检查元素是否存在;二是池允许同一个元素多次出现。池通常有
get()
和
set()
方法。
池在并发系统中有广泛的应用,例如在生产者 - 消费者模型中,生产者线程产生的元素可以先放入池中,消费者线程再从池中取出元素进行处理。当生产者产生元素的速度突然超过消费者处理的速度时,池可以作为缓冲区,暂时存储这些元素。
池有多种类型:
-
有界池和无界池
:有界池只能容纳有限数量的元素,这个数量限制称为容量;无界池则可以容纳任意数量的元素。有界池适用于需要对生产者和消费者线程进行松散同步的场景,确保生产者不会领先消费者太多;无界池适用于不需要对生产者和消费者的差距设置固定限制的场景。
-
方法类型
:
-
总方法(Total)
:调用时不需要等待特定条件为真。例如,从空池中移除元素的
get()
调用会立即返回失败代码或抛出异常;向已满的有界池添加元素的
set()
调用也会立即返回失败代码或异常。当生产者或消费者线程有其他更重要的事情要做,而不想等待方法调用生效时,总接口是合适的选择。
-
部分方法(Partial)
:调用可能需要等待条件满足。例如,从空池中移除元素的部分
get()
调用会阻塞,直到有元素可用;向已满的有界池添加元素的部分
set()
调用会阻塞,直到有空槽可用。当生产者或消费者线程除了等待池变为非满或非空之外没有其他更好的事情可做时,部分接口是合适的选择。
-
同步方法(Synchronous)
:需要等待另一个方法的调用区间重叠。例如,在同步池中,向池添加元素的方法调用会阻塞,直到该元素被另一个方法调用移除;从池中移除元素的方法调用会阻塞,直到另一个方法调用使元素可用。同步池常用于 CSP 和 Ada 等编程语言中,用于线程之间的信息交换。
-
公平性保证
:池可以提供不同的公平性保证,如先进先出(FIFO,队列)、后进先出(LIFO,栈)或其他较弱的属性。在使用池进行缓冲时,公平性非常重要,就像打电话等待客服时,我们希望电话能按照来电顺序被接听。
2. 队列的基本概念
队列是一种提供先进先出(FIFO)公平性的池。顺序队列(Sequential Queue)是一个有序的元素序列,它提供
enq(x)
方法将元素
x
放入队列的一端(称为尾部),以及
deq()
方法从队列的另一端(称为头部)移除并返回元素。并发队列可以线性化为顺序队列,其中
enq()
实现
set()
方法,
deq()
实现
get()
方法。
3. 有界部分队列
为了简化,我们假设向队列中添加空值是非法的。对于一个有多个并发入队者和出队者的有界队列实现,我们期望它能提供多少并发度呢?从直观上看,
enq()
和
deq()
方法分别操作队列的两端,因此只要队列既不满也不空,
enq()
调用和
deq()
调用原则上应该可以互不干扰地进行。但实际上,实现这种并发度并不容易。
我们将有界队列实现为一个链表(也可以使用数组)。以下是有界队列的代码实现:
public class BoundedQueue<T> {
ReentrantLock enqLock, deqLock;
Condition notEmptyCondition, notFullCondition;
AtomicInteger size;
volatile Node head, tail;
int capacity;
public BoundedQueue(int _capacity) {
capacity = _capacity;
head = new Node(null);
tail = head;
size = new AtomicInteger(0);
enqLock = new ReentrantLock();
notFullCondition = enqLock.newCondition();
deqLock = new ReentrantLock();
notEmptyCondition = deqLock.newCondition();
}
public void enq(T x) {
boolean mustWakeDequeuers = false;
enqLock.lock();
try {
while (size.get() == capacity)
notFullCondition.await();
Node e = new Node(x);
tail.next = e;
tail = e;
if (size.getAndIncrement() == 0)
mustWakeDequeuers = true;
} finally {
enqLock.unlock();
}
if (mustWakeDequeuers) {
deqLock.lock();
try {
notEmptyCondition.signalAll();
} finally {
deqLock.unlock();
}
}
}
public T deq() {
T result;
boolean mustWakeEnqueuers = false;
deqLock.lock();
try {
while (size.get() == 0)
notEmptyCondition.await();
result = head.next.value;
head = head.next;
if (size.getAndDecrement() == capacity) {
mustWakeEnqueuers = true;
}
} finally {
deqLock.unlock();
}
if (mustWakeEnqueuers) {
enqLock.lock();
try {
notFullCondition.signalAll();
} finally {
enqLock.unlock();
}
}
return result;
}
protected class Node {
public T value;
public volatile Node next;
public Node(T x) {
value = x;
next = null;
}
}
}
该队列使用两个不同的锁
enqLock
和
deqLock
来确保同一时间最多只有一个入队者和一个出队者可以操作队列对象的字段。每个锁都有一个关联的条件字段:
enqLock
关联
notFullCondition
,用于在队列不再满时通知等待的出队者;
deqLock
关联
notEmptyCondition
,用于在队列不再空时通知等待的入队者。
size
字段是一个
AtomicInteger
,用于跟踪队列中当前的元素数量。
enq()
方法的工作流程如下:
1. 线程获取
enqLock
。
2. 读取
size
字段,如果队列已满(
size
等于容量),则入队者需要等待,直到出队者腾出空间。入队者在
notFullCondition
上等待,暂时释放入队锁,并阻塞直到该条件被信号唤醒。
3. 当有空槽时,入队者创建一个新节点,并将其添加到队列尾部。
4. 如果入队前队列是空的,可能需要唤醒等待的出队者。
deq()
方法的工作流程如下:
1. 线程获取
deqLock
。
2. 读取
size
字段,如果队列为空,则出队者需要等待,直到有元素入队。出队者在
notEmptyCondition
上等待,暂时释放出队锁,并阻塞直到该条件被信号唤醒。
3. 当队列非空时,出队者从队列头部移除一个元素。
4. 如果出队前队列是满的,可能需要唤醒等待的入队者。
这个实现的一个缺点是,并发的
enq()
和
deq()
调用会相互干扰,因为所有方法调用都会对
size
字段进行
getAndIncrement()
或
getAndDecrement()
操作,这些操作比普通的读写操作更昂贵,可能会导致顺序瓶颈。为了减少这种干扰,可以将
size
字段拆分为两个计数器:
enqSideSize
和
deqSideSize
。
4. 无界总队列
无界总队列可以容纳任意数量的元素。
enq()
方法总是能成功入队元素,
deq()
方法在队列为空时会抛出
EmptyException
。其实现与有界队列类似,但不需要跟踪元素数量,也不需要提供等待条件。
public class UnboundedQueue<T> {
ReentrantLock enqLock, deqLock;
volatile Node head, tail;
public UnboundedQueue() {
head = new Node(null);
tail = head;
enqLock = new ReentrantLock();
deqLock = new ReentrantLock();
}
public void enq(T x) {
enqLock.lock();
try {
Node e = new Node(x);
tail.next = e;
tail = e;
} finally {
enqLock.unlock();
}
}
public T deq() throws EmptyException {
T result;
deqLock.lock();
try {
if (head.next == null) {
throw new EmptyException();
}
result = head.next.value;
head = head.next;
} finally {
deqLock.unlock();
}
return result;
}
protected class Node {
public T value;
public volatile Node next;
public Node(T x) {
value = x;
next = null;
}
}
}
class EmptyException extends Exception {
public EmptyException() {
super("Queue is empty");
}
}
这个队列不会发生死锁,因为每个方法只获取一个锁(
enqLock
或
deqLock
)。队列中的哨兵节点不会被删除,因此每个
enq()
调用只要获取到锁就能成功。当然,如果队列为空,
deq()
方法会失败。与前面的队列实现一样,元素实际上在
enq()
调用将最后一个节点的
next
字段设置为新节点时就已经入队,即使
enq()
还没有将
tail
重置为指向新节点。
5. 无界无锁队列
无界无锁队列
LockFreeQueue<T>
是无界总队列的自然扩展,它通过让较快的线程帮助较慢的线程来防止方法调用饥饿。
import java.util.concurrent.atomic.AtomicReference;
public class LockFreeQueue<T> {
private AtomicReference<Node> head;
private AtomicReference<Node> tail;
public LockFreeQueue() {
Node sentinel = new Node(null);
head = new AtomicReference<>(sentinel);
tail = new AtomicReference<>(sentinel);
}
public void enq(T value) {
Node node = new Node(value);
while (true) {
Node last = tail.get();
Node next = last.next.get();
if (last == tail.get()) {
if (next == null) {
if (last.next.compareAndSet(next, node)) {
tail.compareAndSet(last, node);
return;
}
} else {
tail.compareAndSet(last, next);
}
}
}
}
public T deq() throws EmptyException {
while (true) {
Node first = head.get();
Node last = tail.get();
Node next = first.next.get();
if (first == head.get()) {
if (first == last) {
if (next == null) {
throw new EmptyException();
}
tail.compareAndSet(last, next);
} else {
T value = next.value;
if (head.compareAndSet(first, next))
return value;
}
}
}
}
private class Node {
public T value;
public AtomicReference<Node> next;
public Node(T value) {
this.value = value;
next = new AtomicReference<>(null);
}
}
}
class EmptyException extends Exception {
public EmptyException() {
super("Queue is empty");
}
}
队列中的每个节点的
next
字段是一个
AtomicReference<Node>
,队列本身由两个
AtomicReference<Node>
字段
head
和
tail
组成,分别指向队列的第一个和最后一个节点。队列的构造函数将
head
和
tail
都初始化为指向哨兵节点。
enq()
方法是懒惰的,它分两个不同的步骤进行:
1. 调用
compareAndSet()
将新节点追加到队列尾部。
2. 调用
compareAndSet()
将队列的
tail
字段从先前的最后一个节点更新为当前的最后一个节点。
由于这两个步骤不是原子执行的,其他方法调用可能会遇到未完成的
enq()
调用,并帮助完成该工作。
deq()
方法与无界总队列的
deq()
方法类似,但在无锁情况下有一个微妙的问题:在移动
head
之前,必须确保
tail
不会指向即将从队列中移除的哨兵节点。为了避免这个问题,添加了一个测试:如果
head
等于
tail
且它们指向的节点有非空的
next
字段,则更新
tail
。
综上所述,不同类型的队列在并发系统中都有各自的应用场景。有界队列适用于需要控制生产者和消费者速度的场景;无界队列适用于不需要限制元素数量的场景;无锁队列则在高并发环境中提供更好的性能。在实际应用中,需要根据具体需求选择合适的队列类型。
下面是一个简单的 mermaid 流程图,展示无界无锁队列
enq()
方法的工作流程:
graph TD;
A[开始] --> B[创建新节点];
B --> C[获取尾节点 last];
C --> D[获取 last 的下一个节点 next];
D --> E{last 是否等于当前尾节点};
E -- 是 --> F{next 是否为空};
F -- 是 --> G[尝试将新节点追加到 last 后面];
G -- 成功 --> H[尝试更新尾节点为新节点];
H -- 成功 --> I[返回];
F -- 否 --> J[尝试更新尾节点为 next];
J --> C;
G -- 失败 --> C;
H -- 失败 --> I;
E -- 否 --> C;
这个流程图清晰地展示了
enq()
方法的循环过程,包括节点的创建、尾节点的获取、节点的追加和尾节点的更新等步骤。通过这个流程图,可以更好地理解无界无锁队列的入队操作。
在实际应用中,我们可以根据不同的场景选择合适的队列类型。例如,在生产者 - 消费者模型中,如果生产者和消费者的速度差异不大,可以使用有界队列来控制缓冲区的大小;如果生产者产生元素的速度非常快,且不需要限制缓冲区大小,可以使用无界队列;如果对并发性能有较高要求,可以考虑使用无锁队列。
同时,我们也可以根据队列的实现原理,对其进行优化。例如,在有界队列中,可以通过拆分
size
字段来减少并发操作的干扰;在无锁队列中,可以进一步优化
compareAndSet()
操作的使用,提高性能。
总之,并发队列是并发编程中非常重要的一部分,深入理解不同类型队列的特点和实现原理,有助于我们在实际开发中更好地应用它们,提高系统的并发性能和稳定性。
并发队列与 ABA 问题
6. 队列操作的线性化与公平性分析
在并发编程中,线性化是一个重要的概念,它确保并发操作的结果与这些操作按某种顺序依次执行的结果相同。对于队列来说,
enq()
和
deq()
操作都需要满足线性化的要求。
-
线性化点 :
-
有界部分队列
:
enq()操作的线性化点是在入队者观察到有空槽并开始入队操作的瞬间;deq()操作的线性化点是在出队者观察到队列非空并开始出队操作的瞬间。 -
无界总队列
:
enq()操作的线性化点是在tail.next被设置为新节点的瞬间;deq()操作的线性化点是在head被更新为其下一个节点的瞬间。 -
无界无锁队列
:
enq()操作的线性化点是在执行线程(或并发帮助线程)调用compareAndSet()重定向tail字段到新节点的瞬间;deq()操作的线性化点是在head被成功更新为其下一个节点的瞬间。
-
有界部分队列
:
-
公平性 :队列提供的先进先出(FIFO)公平性保证了元素按照入队的顺序出队。在并发环境中,这种公平性对于许多应用场景非常重要,例如任务调度、消息传递等。不同类型的队列在实现公平性时采用了不同的方法:
- 有界部分队列 :通过使用锁和条件变量来确保入队和出队操作的顺序,从而保证 FIFO 公平性。
- 无界总队列 :同样使用锁来控制并发访问,保证元素按照入队顺序出队。
- 无界无锁队列 :通过原子操作和帮助机制来实现公平性,确保每个元素都能按照入队顺序被处理。
7. 不同队列类型的性能比较
不同类型的队列在并发性能上有不同的表现,下面从几个方面进行比较:
| 队列类型 | 并发度 | 锁的使用 | 同步开销 | 适用场景 |
|---|---|---|---|---|
| 有界部分队列 |
有限,
enq()
和
deq()
操作在队列非空非满时可并发,但
size
操作可能成为瓶颈
|
使用两个锁
enqLock
和
deqLock
| 较高,频繁的锁获取和释放以及条件变量的等待和唤醒 | 生产者和消费者速度差异不大,需要控制缓冲区大小的场景 |
| 无界总队列 | 有限,每个方法只获取一个锁,避免了死锁,但并发度仍受锁的限制 |
使用两个锁
enqLock
和
deqLock
| 适中,锁的获取和释放开销 | 不需要限制元素数量,对并发度要求不高的场景 |
| 无界无锁队列 | 较高,通过原子操作和帮助机制实现无锁并发 | 无锁 | 较低,避免了锁的开销,但原子操作有一定成本 | 高并发环境,对性能要求较高的场景 |
8. 队列实现中的常见问题及解决方案
在队列的实现过程中,可能会遇到一些常见的问题,下面介绍这些问题及相应的解决方案:
-
丢失唤醒问题 :在有界部分队列中,入队者在发现队列已满时会等待
notFullCondition,而出队者在使队列不再满时会信号该条件。如果处理不当,可能会出现入队者丢失唤醒的情况。解决方案是在信号条件之前获取相应的锁,确保入队者在等待和被唤醒的过程中不会错过信号。 -
ABA 问题 :虽然本文未详细提及 ABA 问题,但在无锁队列的实现中,ABA 问题是一个潜在的风险。ABA 问题指的是一个值从 A 变为 B,再变回 A,而其他线程可能无法察觉这个变化。在无锁队列中,如果使用
compareAndSet()操作,可能会因为 ABA 问题导致操作错误。解决方案可以是使用带有版本号的原子引用,每次值发生变化时版本号也随之改变,这样在比较时不仅比较值,还比较版本号。 -
性能瓶颈问题 :有界部分队列中
size字段的操作可能成为性能瓶颈。解决方案是将size字段拆分为两个计数器enqSideSize和deqSideSize,减少并发操作的干扰。
9. 队列在实际应用中的案例
队列在实际应用中有广泛的用途,下面介绍几个常见的案例:
-
生产者 - 消费者模型 :这是队列最常见的应用场景之一。生产者线程将任务或数据放入队列,消费者线程从队列中取出任务或数据进行处理。不同类型的队列可以根据生产者和消费者的速度差异以及系统的并发需求进行选择。例如,在一个电商系统中,订单处理可以采用生产者 - 消费者模型,生产者线程负责接收用户的订单,将其放入队列,消费者线程负责处理订单。
-
任务调度 :在操作系统或分布式系统中,任务调度通常使用队列来管理任务的执行顺序。例如,操作系统的任务队列可以确保任务按照提交的顺序依次执行,保证公平性。
-
消息传递 :在分布式系统中,消息队列用于不同节点之间的消息传递。生产者节点将消息发送到队列,消费者节点从队列中接收消息。无锁队列在高并发的消息传递场景中可以提供更好的性能。
10. 总结与展望
本文详细介绍了并发队列的相关知识,包括池的概念、不同类型的队列(有界部分队列、无界总队列、无界无锁队列)及其实现原理、线性化与公平性分析、性能比较、常见问题及解决方案以及实际应用案例。不同类型的队列在并发系统中都有各自的优势和适用场景,在实际应用中需要根据具体需求进行选择。
未来,随着计算机硬件的发展和并发编程需求的增加,队列的实现可能会进一步优化。例如,在多核处理器和分布式系统中,如何设计更高效的无锁队列将是一个研究热点。同时,如何更好地解决队列实现中的复杂问题,如 ABA 问题和性能瓶颈问题,也需要进一步的研究和探索。
下面是一个 mermaid 流程图,展示生产者 - 消费者模型中使用队列的工作流程:
graph LR;
A[生产者] --> B[入队操作 enq()];
B --> C[队列];
C --> D[出队操作 deq()];
D --> E[消费者];
这个流程图清晰地展示了生产者 - 消费者模型中队列的作用,生产者将数据入队,消费者从队列中出队数据进行处理。通过这个流程图,可以更好地理解队列在实际应用中的工作原理。
总之,并发队列是并发编程中不可或缺的一部分,深入研究和掌握并发队列的知识对于提高系统的并发性能和稳定性具有重要意义。
268



被折叠的 条评论
为什么被折叠?



