无锁链表算法:从延迟同步到无阻塞同步
在并发编程中,链表的同步机制是一个重要的研究领域。我们先从延迟同步(Lazy Synchronization)的概念入手,逐步深入探讨无阻塞同步(Non - Blocking Synchronization)的实现。
延迟同步的特点
延迟同步的一个好处是可以将一些不影响结构的逻辑操作(如设置标志)与对结构有较大影响的物理操作(如断开节点连接)分开。例如,在链表操作中,我们可以一次断开一个节点。通常,延迟操作可以批量处理,并在合适的时间进行,这样可以减少对结构物理修改的整体影响。
不过,延迟链表(LazyList)算法也有其缺点,其
add()
和
remove()
方法是阻塞的。也就是说,如果一个线程被延迟,其他线程可能也会受到影响。
无阻塞同步的需求与挑战
我们知道,在从链表中物理移除节点之前,先将节点标记为逻辑移除是一个不错的做法。现在,我们要进一步扩展这个想法,以实现完全无锁的链表,让
add()
、
remove()
和
contains()
这三个方法都能实现无阻塞操作(前两个方法是无锁的,最后一个是无等待的)。
一个简单的想法是使用
compareAndSet()
方法来修改
next
字段,但这种方法并不总是可行。例如,当线程A尝试移除节点a,而线程B尝试添加节点b时,可能会出现节点a被正确删除,但节点b未能添加到链表中的情况。同样,当两个线程同时尝试移除相邻节点时,也可能会导致某些节点无法被正确移除。
AtomicMarkableReference的引入
为了确保节点在逻辑或物理移除后其字段不能被更新,我们将节点的
next
和
marked
字段视为一个原子单元。在Java中,我们使用
AtomicMarkableReference<T>
类来实现这一功能。
AtomicMarkableReference<T>
是
java.util.concurrent.atomic
包中的一个对象,它封装了一个类型为T的对象引用和一个布尔标记。这些字段可以原子地更新,既可以一起更新,也可以单独更新。以下是它的一些方法:
public boolean compareAndSet(T expectedReference,
T newReference,
boolean expectedMark,
boolean newMark);
public boolean attemptMark(T expectedReference,
boolean newMark);
public T get(boolean[] marked);
在C或C++中,可以通过从指针中“窃取”一位,并使用位运算符从单个字中提取标记和指针来高效地实现这一功能。但在Java中,由于不能直接操作指针,所以需要通过库来提供这一功能。
LockFreeList算法的实现
我们让每个节点的
next
字段成为
AtomicMarkableReference<Node>
类型。线程A通过设置节点
next
字段中的标记位来逻辑移除节点
currA
,并与执行
add()
或
remove()
操作的其他线程共同完成物理移除操作。每个线程在遍历链表时,会使用
compareAndSet()
方法物理移除遇到的标记节点。
为了区分
LockFreeList
算法和
LazyList
算法,我们来分析一下设计决策。在
LockFreeList
算法中,执行
add()
和
remove()
操作的线程不会遍历标记节点,而是直接移除它们。这是因为如果线程A遍历标记节点而不物理移除它们,在尝试物理移除节点时,由于没有持有锁,其他线程可能会插入新节点或移除前驱节点,导致操作失败,甚至需要重新遍历链表。
为了实现
LockFreeList
算法,我们创建了一个内部
Window
类来帮助导航。以下是
Window
类和
find()
方法的代码:
class Window {
public Node pred, curr;
Window(Node myPred, Node myCurr) {
pred = myPred; curr = myCurr;
}
}
public Window find(Node head, int key) {
Node pred = null, curr = null, succ = null;
boolean[] marked = {false};
boolean snip;
retry: while (true) {
pred = head;
curr = pred.next.getReference();
while (true) {
succ = curr.next.get(marked);
while (marked[0]) {
snip = pred.next.compareAndSet(curr, succ, false, false);
if (!snip) continue retry;
curr = succ;
succ = curr.next.get(marked);
}
if (curr.key >= key)
return new Window(pred, curr);
pred = curr;
curr = succ;
}
}
}
find()
方法返回一个包含键两侧节点的结构,并在遇到标记节点时将其移除。其中,
compareAndSet()
调用是一个良性副作用的例子,它改变了具体的链表结构,但不改变抽象集合的状态。
以下是
LockFreeList
算法的
add()
、
remove()
和
contains()
方法的代码:
public boolean add(T item) {
int key = item.hashCode();
while (true) {
Window window = find(head, key);
Node pred = window.pred, curr = window.curr;
if (curr.key == key) {
return false;
} else {
Node node = new Node(item);
node.next = new AtomicMarkableReference(curr, false);
if (pred.next.compareAndSet(curr, node, false, false)) {
return true;
}
}
}
}
public boolean remove(T item) {
int key = item.hashCode();
boolean snip;
while (true) {
Window window = find(head, key);
Node pred = window.pred, curr = window.curr;
if (curr.key != key) {
return false;
} else {
Node succ = curr.next.getReference();
snip = curr.next.compareAndSet(succ, succ, false, true);
if (!snip)
continue;
pred.next.compareAndSet(curr, succ, false, false);
return true;
}
}
}
public boolean contains(T item) {
boolean[] marked = false;
int key = item.hashCode();
Node curr = head;
while (curr.key < key) {
curr = curr.next.getReference();
Node succ = curr.next.get(marked);
}
return (curr.key == key && !marked[0])
}
不同算法的对比
| 算法 | 优点 | 缺点 |
|---|---|---|
| LockFreeList算法 | 能在任意延迟的情况下保证进度 | 需要支持引用和布尔标记的原子修改,有额外的性能开销;在遍历链表时需要进行并发清理,可能导致线程竞争,有时需要重新遍历链表 |
| LazyList算法 | 不需要每个节点包含可原子标记的引用;遍历链表时不需要清理逻辑移除的节点 |
add()
和
remove()
方法是阻塞的,不能在任意延迟的情况下保证进度
|
总结
在设计并发数据结构时,我们看到了从基于锁的链表实现逐渐过渡到完全无阻塞链表的过程。从
LazyList
到
LockFreeList
的转变,揭示了并发程序员在设计时面临的一些决策。像乐观同步和延迟同步这样的方法,在设计更复杂的数据结构时会反复出现。选择哪种方法取决于具体的应用场景,需要综合考虑线程延迟的可能性、
add()
和
remove()
方法的调用频率、实现可原子标记引用的开销等因素。
练习题分析
以下是一些相关的练习题及分析:
1.
描述如何修改链表算法以处理对象哈希码不唯一的情况
:当对象哈希码不唯一时,不能仅仅依靠哈希码来判断节点是否存在。可以在节点中添加额外的字段(如对象的引用)来进行精确比较。在
add()
、
remove()
和
contains()
方法中,除了比较哈希码,还需要比较对象的实际内容。
2.
解释为什么细粒度锁定算法不会出现死锁
:细粒度锁定算法通常按照固定的顺序获取锁,避免了循环等待的情况。例如,在遍历链表时,总是从前往后依次获取节点的锁,这样就不会出现线程A等待线程B持有的锁,而线程B又等待线程A持有的锁的情况。
3.
解释为什么细粒度链表的
add()
方法是可线性化的
:可线性化要求操作看起来像是在某个瞬间原子地执行。在细粒度链表的
add()
方法中,通过使用锁来保证在插入节点的过程中,其他线程不会对链表进行干扰。具体来说,在获取前驱节点和当前节点的锁后,操作是原子的,因此可以保证可线性化。
4.
解释为什么乐观和延迟锁定算法不会出现死锁
:乐观锁定算法在操作前不获取锁,而是在操作完成后检查是否有冲突。如果有冲突,则重试操作。延迟锁定算法虽然使用锁,但在逻辑移除节点时并不持有锁,而是在物理移除节点时才获取锁,避免了循环等待的情况。
5.
展示乐观算法中线程永远尝试删除节点的场景
:假设存在一个坏的执行序列,不断有线程添加和移除节点。当一个线程尝试删除节点时,由于其他线程不断地添加和移除节点,导致该线程在验证操作时总是失败,从而需要不断重试。
6.
提供细粒度算法中缺失的
contains()
方法的代码并解释其正确性
:
public boolean contains(T item) {
int key = item.hashCode();
Node curr = head.next;
while (curr != null && curr.key < key) {
curr = curr.next;
}
return curr != null && curr.key == key && !curr.marked;
}
该方法从链表头开始遍历,直到找到一个键大于等于目标键的节点。如果找到的节点键等于目标键且未被标记,则返回
true
,否则返回
false
。由于在遍历过程中没有修改链表结构,所以不会受到并发操作的影响,保证了正确性。
7.
如果乐观列表实现中交换
add()
方法锁定
pred
和
curr
条目的顺序,是否仍然正确
:交换顺序可能会导致死锁。因为如果线程A先锁定
curr
,线程B先锁定
pred
,然后它们都尝试获取对方持有的锁,就会出现循环等待的情况,导致死锁。
8.
证明在乐观列表算法中,如果
predA
不为空,则从
predA
可以到达
tail
,即使
predA
本身不可达
:在乐观列表算法中,链表的结构是有序的。由于
predA
是在遍历过程中找到的,它后面的节点是按照顺序排列的,所以从
predA
可以到达
tail
。即使
predA
本身可能因为其他操作而不可达,但它后面的节点关系仍然保持不变。
9.
证明在乐观算法中,
add()
方法只需要锁定
pred
:在
add()
方法中,主要的操作是在
pred
节点后面插入新节点。只需要锁定
pred
节点,就可以保证在插入过程中其他线程不会修改
pred
的
next
字段,从而保证操作的原子性。
10.
在乐观算法中,
contains()
方法在决定键是否存在之前锁定两个条目。如果不锁定任何条目,直接根据观察结果返回
true
或
false
,是否可线性化
:这种替代方法可能不是可线性化的。因为在不锁定条目的情况下,其他线程可能会同时修改链表结构,导致
contains()
方法观察到的结果可能是不一致的。例如,在
contains()
方法遍历过程中,其他线程可能会插入或移除节点,使得观察结果不能反映操作的原子性。
11.
如果简单地将节点的
next
字段设置为
null
来标记节点已移除,延迟算法和无锁算法是否仍然有效
:
-
延迟算法
:可能无效。因为延迟算法依赖于
marked
字段来逻辑移除节点,在物理移除节点时需要检查节点的标记状态。如果简单地将
next
字段设置为
null
,可能会导致其他线程无法正确判断节点的状态,从而影响算法的正确性。
-
无锁算法
:也可能无效。无锁算法同样依赖于
AtomicMarkableReference
来保证节点的标记和引用的原子更新。将
next
字段设置为
null
无法实现这种原子性,可能会导致并发操作时出现错误。
12.
在延迟算法中,
predA
是否可能不可达
:在延迟算法中,
predA
通常是可达的。因为在遍历链表时,
predA
是当前节点的前驱节点,并且在逻辑移除节点时,不会影响
predA
的可达性。只有在其他线程进行复杂的操作(如移除
predA
的前驱节点)时,才可能导致
predA
不可达,但这种情况可以通过算法的验证机制来避免。
13.
新员工声称可以通过删除延迟列表验证方法中
pred.next
等于
curr
的检查来简化代码,解释这种推理的错误
:虽然代码通常会将
pred
设置为
curr
的旧值,但在多线程环境下,其他线程可能会在验证之前修改
pred.next
字段。如果删除这个检查,可能会导致验证结果不准确,从而影响算法的正确性。
14.
能否修改延迟算法的
remove()
方法,使其只锁定一个节点
:可以尝试只锁定当前节点
curr
。在逻辑移除节点时,不需要锁定前驱节点
pred
。在物理移除节点时,通过检查
pred.next
是否仍然指向
curr
来确保操作的正确性。但这种修改需要仔细考虑并发情况下的各种情况,以避免出现错误。
15.
在无锁算法中,讨论
contains()
方法帮助清理逻辑移除条目的优缺点
:
-
优点
:可以及时清理链表中的逻辑移除节点,减少内存占用,提高后续操作的效率。
-
缺点
:
contains()
方法原本是无等待的,如果参与清理操作,可能会增加操作的时间复杂度,并且可能会导致线程竞争,影响性能。
16.
在无锁算法中,如果
add()
方法调用失败是因为
pred
不指向
curr
,但
pred
未被标记,是否需要从链表头重新遍历以完成调用
:通常需要从链表头重新遍历。因为
pred
不指向
curr
说明链表结构已经发生了变化,为了确保操作的正确性,需要重新找到正确的前驱节点和当前节点。
17.
如果逻辑移除的条目不保证有序,延迟和无锁算法的
contains()
方法是否仍然正确
:仍然正确。
contains()
方法主要通过比较节点的键和标记来判断节点是否存在,与逻辑移除条目是否有序无关。只要能够正确判断节点的标记状态,就可以准确判断条目是否在链表中。
18.
无锁算法的
add()
方法从未找到具有相同键的标记节点。能否修改算法,使其在存在相同键的标记节点时,直接将新对象插入到该节点中,从而节省插入新节点的需要
:可以尝试修改算法。在
add()
方法中,当找到具有相同键的标记节点时,直接更新该节点的内容。但需要注意并发情况下的一致性问题,例如其他线程可能同时对该节点进行操作,需要使用
compareAndSet()
方法来保证操作的原子性。
19.
解释为什么在
LockFreeList
算法中不会出现以下情况:一个线程逻辑移除但尚未物理移除包含项
x
的节点,另一个线程将相同的项
x
添加到链表中,最后第三个线程的
contains()
调用遍历链表,找到逻辑移除的节点并返回
false
,尽管
remove()
和
add()
的线性化顺序意味着
x
在集合中
:在
LockFreeList
算法中,
contains()
方法会检查节点的标记状态。如果节点被逻辑移除,
marked
字段为
true
,但在
add()
操作中,如果发现节点已被标记,会重新插入新节点。因此,当
contains()
方法遍历链表时,会根据最新的链表状态来判断节点是否存在,不会出现上述情况。
无锁链表算法:从延迟同步到无阻塞同步
操作步骤总结
为了更清晰地理解这些算法的使用,下面总结了
LockFreeList
算法中主要方法的操作步骤:
add()
方法操作步骤
- 计算待添加项的哈希码。
-
调用
find()方法找到合适的插入位置,获取前驱节点pred和当前节点curr。 -
检查
curr的键是否与待添加项的键相同,如果相同则返回false。 -
创建新节点,并将其
next字段指向curr。 -
使用
compareAndSet()方法尝试将pred的next字段从curr更新为新节点,如果成功则返回true,否则重新开始步骤2。
remove()
方法操作步骤
- 计算待移除项的哈希码。
-
调用
find()方法找到待移除节点,获取前驱节点pred和当前节点curr。 -
检查
curr的键是否与待移除项的键相同,如果不同则返回false。 -
获取
curr的后继节点succ。 -
使用
compareAndSet()方法尝试将curr的marked字段设置为true,如果失败则重新开始步骤2。 -
使用
compareAndSet()方法将pred的next字段从curr更新为succ,返回true。
contains()
方法操作步骤
- 计算待查找项的哈希码。
- 从链表头开始遍历,直到找到键大于等于待查找项的节点。
-
检查该节点的键是否与待查找项的键相同,并且该节点未被标记,如果满足条件则返回
true,否则返回false。
流程图
下面是
LockFreeList
算法中
find()
方法的mermaid流程图:
graph TD;
A[开始] --> B[设置pred为头节点];
B --> C[设置curr为pred的下一个节点];
C --> D{curr是否为目标节点或超出范围};
D -- 否 --> E[获取curr的后继节点succ和标记状态];
E --> F{标记状态是否为true};
F -- 是 --> G[尝试移除curr节点];
G -- 失败 --> B[重新开始];
G -- 成功 --> C[设置curr为succ];
F -- 否 --> H[更新pred为curr];
H --> I[更新curr为succ];
I --> D{curr是否为目标节点或超出范围};
D -- 是 --> J[返回包含pred和curr的Window对象];
深入分析与拓展思考
在实际应用中,我们还可以对这些算法进行进一步的拓展和优化。例如,可以考虑使用更高效的哈希函数来减少哈希冲突,提高算法的性能。另外,对于并发清理操作,可以采用批量清理的方式,减少线程之间的竞争。
在多线程环境下,还需要考虑线程的调度和资源分配问题。例如,当线程竞争激烈时,可能会导致某些线程长时间得不到执行,影响算法的整体性能。可以通过调整线程的优先级或者使用线程池来优化线程的调度。
未来趋势与展望
随着计算机技术的不断发展,并发编程的需求越来越高。无阻塞同步算法作为并发编程中的重要技术,将会在更多的领域得到应用。例如,在分布式系统、大数据处理等领域,无阻塞同步算法可以提高系统的并发性能和可靠性。
未来,我们可以期待更高效、更稳定的无阻塞同步算法的出现。例如,结合硬件特性(如原子指令)来进一步优化算法的性能,或者采用新的并发模型(如事务内存)来简化并发编程的复杂度。
总结回顾
本文从延迟同步的概念出发,详细介绍了无阻塞同步的实现,重点分析了
LockFreeList
算法的原理和实现细节。通过对比
LockFreeList
算法和
LazyList
算法,我们了解了不同算法的优缺点和适用场景。同时,通过练习题的分析,我们进一步加深了对这些算法的理解和应用能力。
在实际应用中,我们需要根据具体的需求和场景选择合适的算法。例如,如果对线程延迟比较敏感,并且对并发性能要求较高,可以选择
LockFreeList
算法;如果对并发性能要求不是特别高,并且希望避免复杂的原子操作,可以选择
LazyList
算法。
总之,并发编程是一个充满挑战和机遇的领域,无阻塞同步算法为我们提供了一种有效的解决方案。通过不断学习和实践,我们可以更好地掌握并发编程的技术,开发出高效、稳定的并发应用程序。
参考表格
| 算法特性 | LockFreeList算法 | LazyList算法 |
|---|---|---|
| 同步方式 | 无锁同步 | 延迟锁同步 |
| 进度保证 | 任意延迟下保证进度 | 可能因线程延迟阻塞 |
| 节点结构 | 包含AtomicMarkableReference | 普通节点结构 |
| 遍历清理 | 遍历中清理标记节点 | 忽略标记节点 |
| 适用场景 | 高并发、对延迟敏感 | 并发较低、对性能开销敏感 |
通过这个表格,我们可以更直观地对比两种算法的特点,为实际应用中的选择提供参考。
616



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



