并发编程中的互斥与并发对象
在并发编程领域,互斥和并发对象的行为是核心研究内容。下面将详细探讨互斥算法的相关问题以及并发对象的正确性和一致性。
互斥算法相关问题
-
覆盖状态的达成
- 从LB的覆盖状态开始。
- 运行系统直到A即将写入LA。若不存在这种情况,让A进入临界区,B可能会覆盖其值,且A可能在LB留下痕迹。
- 再次运行B,它会擦除LB中的痕迹,然后让其进入临界区并返回。重复此模式两次以上,B必须回到相同位置(如图中的LB)的覆盖状态。
-
相关算法的历史
- “→”形式化表示由Leslie Lamport提出。
- 前三个算法由Gary Peterson于1981年发表。
- 本文介绍的面包店锁是Leslie Lamport原始面包店算法的简化版。
- 顺序时间戳算法由Amos Israeli和Ming Li发明。
- Danny Dolev和Nir Shavit发明了第一个有界并发时间戳系统。
- Jim Burns和Nancy Lynch得出了锁字段数量的下限,其证明技术“覆盖论证”被广泛用于分布式计算的下限证明。
-
练习题分析
- 练习9 :定义r - 有界等待,即若$D_j^A → D_k^B$,则$CS_j^A → CS_{k + r}^B$。探讨是否能为Peterson算法定义一个门道,使其满足某个r值的r - 有界等待。
-
练习10
:解释为何需要定义门道部分,以及为何不能基于
lock()方法中第一条指令的执行顺序来定义先进先出(FCFS),需根据第一条指令是读还是写、操作的是不同位置还是相同位置进行逐例分析。 - 练习11 :分析Flaky Computer Corporation设计的协议,判断其是否满足互斥、无饥饿和无死锁特性。以下是该协议的代码:
class Flaky implements Lock {
private int turn;
private boolean busy = false;
public void lock() {
int me = ThreadID.get();
do {
do {
turn = me;
} while (busy);
busy = true;
} while (turn != me);
}
public void unlock() {
busy = false;
}
}
- **练习12**:证明Filter锁允许某些线程任意次数地超越其他线程。
- **练习13**:将多个双线程Peterson锁排列成二叉树来推广双线程Peterson锁。分析该树锁是否满足互斥、无死锁和无饥饿特性,以及是否存在线程从开始获取树锁到成功获取期间,树锁获取和释放次数的上限。
- **练习14**:修改n进程Filter互斥算法,使其成为ℓ - 排除算法,该算法允许最多ℓ个线程同时处于临界区,且在少于ℓ个线程在临界区时,想进入临界区的线程最终能成功。
- **练习15**:分析Cantaloupe - Melon大学科学家设计的“包装器”FastPath锁。若基础Lock类提供互斥和无饥饿特性,他们声称FastPath锁也具备这些特性,且在无竞争时能以恒定步数获取锁。以下是FastPath锁的代码:
class FastPath implements Lock {
private static ThreadLocal<Integer> myIndex;
private Lock lock;
private int x, y = -1;
public void lock() {
int i = myIndex.get();
x = i;
while (y != -1) {}
y = i;
if (x != i)
lock.lock();
}
public void unlock() {
y = -1;
lock.unlock();
}
}
- **练习16**:假设有n个线程调用Bouncer类的`visit()`方法,证明最多一个线程得到值STOP,最多n - 1个线程得到值DOWN,最多n - 1个线程得到值RIGHT。以下是Bouncer类的代码:
class Bouncer {
public static final int DOWN = 0;
public static final int RIGHT = 1;
public static final int STOP = 2;
private boolean goRight = false;
private ThreadLocal<Integer> myIndex;
private int last = -1;
int visit() {
int i = myIndex.get();
last = i;
if (goRight)
return RIGHT;
goRight = true;
if (last == i)
return STOP;
else
return DOWN;
}
}
- **练习17**:将Bouncer对象排列成三角矩阵为线程分配唯一小索引。证明每个线程最终会在某个Bouncer对象处停止,并计算若提前知道线程总数n,数组中需要多少个Bouncer对象。
- **练习18**:通过反例证明顺序时间戳系统T3在三个线程并发情况下不适用,需展示三个标签未完全有序的执行状态。
- **练习19**:设计一个顺序时间戳系统,使其只需要$O(n2^n)$个标签,可从标签的位表示角度思考。
- **练习20**:用无界标签实现Timestamp接口的Java代码,并展示如何用该代码替换面包店锁的伪代码。
并发对象的正确性与一致性
-
并发对象的正确性
-
以一个简单的基于锁的并发FIFO队列为例,其
enq()和deq()方法通过互斥锁同步,每个方法在持有排他锁时访问和更新字段,方法调用顺序执行,因此该实现是正确的并发FIFO队列。以下是该队列的代码:
-
以一个简单的基于锁的并发FIFO队列为例,其
class LockBasedQueue<T> {
int head, tail;
T[] items;
Lock lock;
public LockBasedQueue(int capacity) {
head = 0; tail = 0;
lock = new ReentrantLock();
items = (T[])new Object[capacity];
}
public void enq(T x) throws FullException {
lock.lock();
try {
if (tail - head == items.length)
throw new FullException();
items[tail % items.length] = x;
tail++;
} finally {
lock.unlock();
}
}
public T deq() throws EmptyException {
lock.lock();
try {
if (tail == head)
throw new EmptyException();
T x = items[head % items.length];
head++;
return x;
} finally {
lock.unlock();
}
}
}
- 然而,对于一个无锁的单入队者/单出队者FIFO队列,虽然其结构与基于锁的队列相似,但由于没有锁的协调,难以解释其为何是正确的FIFO队列,也不清楚在入队和出队并发时队列的FIFO含义。以下是该队列的代码:
class WaitFreeQueue<T> {
volatile int head = 0, tail = 0;
T[] items;
public WaitFreeQueue(int capacity) {
items = (T[]) new Object[capacity];
}
public void enq(T x) throws FullException {
if (tail - head == items.length)
throw new FullException();
items[tail % items.length] = x;
tail++;
}
public T deq() throws EmptyException {
if (tail - head == 0)
throw new EmptyException();
T x = items[head % items.length];
head++;
return x;
}
}
- 由于Amdahl定律,持有排他锁的并发对象不如细粒度锁或无锁的对象理想,因此需要一种不依赖方法级锁来指定并发对象行为并推理其实现的方法。将并发执行映射到顺序执行并限制推理范围是本章引入的正确性属性的关键。
-
顺序对象
- 在Java和C++等语言中,对象是数据的容器,通过一组方法来操作。对象有类,类定义了对象的方法和行为,对象有明确定义的状态。
- API文档通常通过前置条件和后置条件描述对象方法的行为,这种描述方式在单线程计算模型中很有效,但在多线程共享对象时会失效。因为多线程中方法调用可能重叠,无法确定其顺序,对象状态也变得模糊,方法调用可能会遇到反映其他并发方法未完成效果的对象状态。
-
静止一致性
- 方法调用有时间跨度,从调用事件开始到响应事件结束。并发线程的方法调用可能重叠,单线程的方法调用总是顺序的。若调用事件发生但响应事件未发生,则称该方法调用为挂起状态。
- 以两个线程同时向共享寄存器r写入 - 3和7,随后一个线程读取r返回 - 7为例,这种行为不可接受,由此引出原则:方法调用应按一次一个的顺序依次发生。但该原则通常太弱,例如它允许读取总是返回对象的初始状态。
- 一个对象若没有挂起的方法调用,则称其为静止状态。引出更强的原则:被静止期分隔的方法调用应按实时顺序生效。
-
这两个原则共同定义了静止一致性属性,即对象静止时,到目前为止的执行等效于已完成调用的某种顺序执行。例如,共享计数器是静止一致对象,它返回的数字不一定按
getAndIncrement()请求的顺序,但不会重复或遗漏数字。
通过对互斥算法和并发对象的研究,我们能更好地理解并发编程中的关键概念和技术,为开发高效、正确的并发程序提供理论支持。
并发编程中的互斥与并发对象(下半部分)
并发对象正确性条件的深入探讨
-
不同正确性条件的适用场景
- 并发对象的正确性有多种衡量标准,不同标准适用于不同的系统。
- 静止一致性 :适用于那些追求高性能,但对对象行为约束相对较弱的应用。例如在一些对数据实时性要求不高,但对系统吞吐量要求较高的场景中,静止一致性可以允许系统在一定程度上的并发操作,只要在系统静止时能保证数据的一致性即可。
- 顺序一致性 :是一个更强的条件,常用于描述底层系统,如硬件内存接口。在硬件层面,顺序一致性可以确保内存操作按照程序的顺序依次执行,避免出现数据不一致的问题,保证系统的稳定性和可靠性。
- 线性一致性 :是最强的条件,适用于描述由线性一致组件组成的高层系统。在一些对数据准确性和操作顺序要求极高的系统中,如金融交易系统,线性一致性可以保证每一个操作都能在瞬间完成,并且操作的顺序与程序的顺序一致,避免出现数据错误和交易冲突。
-
并发对象的进度保证
- 不同的方法实现为并发对象提供了不同的进度保证,主要分为阻塞和非阻塞两种类型。
- 阻塞类型 :在这种类型中,任何一个线程的延迟都可能导致其他线程的延迟。例如在基于锁的并发编程中,如果一个线程持有锁的时间过长,其他需要获取该锁的线程就会被阻塞,从而导致整个系统的性能下降。
- 非阻塞类型 :一个线程的延迟不会影响其他线程的执行。非阻塞算法通常使用原子操作和无锁数据结构,使得每个线程都能独立地执行自己的任务,不会因为其他线程的延迟而受到影响,从而提高了系统的并发性能。
并发对象相关概念的总结与对比
| 概念 | 定义 | 适用场景 | 特点 |
|---|---|---|---|
| 静止一致性 | 对象静止时,执行等效于已完成调用的某种顺序执行 | 追求高性能、对对象行为约束弱的应用 | 允许一定程度并发,静止时保证数据一致 |
| 顺序一致性 | 方法调用按程序顺序依次执行 | 底层系统,如硬件内存接口 | 保证操作顺序,提高系统稳定性 |
| 线性一致性 | 每个操作瞬间完成,顺序与程序顺序一致 | 高层系统,如金融交易系统 | 保证数据准确,避免操作冲突 |
| 阻塞类型 | 一个线程延迟可能导致其他线程延迟 | 基于锁的并发编程 | 性能受持有锁线程影响 |
| 非阻塞类型 | 一个线程延迟不影响其他线程执行 | 对并发性能要求高的场景 | 线程独立执行,提高并发性能 |
并发编程中的实际应用与挑战
-
并发对象实现的优化
- 在实际应用中,大多数锁的获取是无竞争的,因此衡量锁性能的一个重要指标是在没有其他线程同时竞争时,线程获取锁所需的步骤数。
- 例如Cantaloupe - Melon大学科学家设计的FastPath锁,通过一个“包装器”来优化锁的获取过程。在无竞争的情况下,它可以在恒定步数内获取锁,提高了系统的性能。但在有竞争的情况下,它仍然需要依赖基础锁来保证互斥和无饥饿特性。
- 对于这种优化,我们需要考虑其在不同场景下的性能表现。在无竞争场景下,FastPath锁的优势明显,但在高并发场景下,可能需要进一步优化其竞争处理机制,以避免性能下降。
-
并发编程中的挑战与解决方案
- 线程同步问题 :在多线程环境中,线程同步是一个关键问题。如果线程同步不当,可能会导致数据不一致、死锁等问题。例如在Flaky锁的实现中,如果多个线程同时竞争锁,可能会出现死锁的情况。为了解决线程同步问题,我们可以使用各种同步机制,如锁、信号量、原子操作等。
- 性能优化问题 :并发编程的一个重要目标是提高系统的性能。但在实际应用中,我们需要平衡并发度和性能之间的关系。例如在使用锁时,锁的粒度太大会导致并发度降低,性能下降;锁的粒度太小会增加锁的管理开销,也会影响性能。因此,我们需要根据具体的应用场景选择合适的锁粒度。
- 可扩展性问题 :随着系统规模的扩大,并发编程的可扩展性成为一个挑战。例如在将多个双线程Peterson锁排列成二叉树来实现树锁时,需要考虑树锁在大规模线程环境下的性能和可扩展性。为了解决可扩展性问题,我们可以使用分布式算法、并行计算等技术。
并发编程的未来发展趋势
-
硬件技术的发展对并发编程的影响
- 随着硬件技术的不断发展,多核处理器、GPU等并行计算设备的性能不断提高。这为并发编程带来了更多的机遇和挑战。
- 多核处理器可以提供更高的并发度,使得程序可以同时执行多个线程,提高系统的性能。但同时,多核处理器也带来了线程同步、缓存一致性等问题,需要我们开发更高效的并发算法和同步机制。
- GPU的并行计算能力非常强大,适用于处理大规模的数据并行任务。例如在深度学习、图像处理等领域,GPU可以显著提高程序的性能。但GPU编程需要特殊的编程模型和算法,需要我们不断学习和探索。
-
新兴技术在并发编程中的应用
- 人工智能与机器学习 :人工智能和机器学习算法通常需要处理大量的数据和复杂的计算任务,并发编程可以提高这些算法的执行效率。例如在深度学习中,使用并发编程可以加速神经网络的训练过程。
- 区块链技术 :区块链是一种分布式账本技术,需要处理大量的并发交易。并发编程可以提高区块链系统的吞吐量和响应速度,保证系统的稳定性和可靠性。
总结
并发编程是现代计算机科学中的一个重要领域,互斥算法和并发对象是并发编程中的核心概念。通过对互斥算法的研究,我们可以更好地解决线程同步问题,保证程序的正确性和可靠性。通过对并发对象的研究,我们可以选择合适的正确性条件和进度保证,提高系统的性能和可扩展性。
在未来的并发编程中,我们需要不断关注硬件技术的发展和新兴技术的应用,开发更高效、更可靠的并发算法和同步机制,以应对日益复杂的并发编程挑战。同时,我们也需要加强对并发编程的理论研究,为并发编程的实践提供更坚实的理论支持。
graph LR
A[并发编程] --> B[互斥算法]
A --> C[并发对象]
B --> B1[覆盖状态达成]
B --> B2[相关算法历史]
B --> B3[练习题分析]
C --> C1[正确性与一致性]
C --> C2[不同正确性条件]
C --> C3[实际应用与挑战]
C1 --> C11[基于锁的队列]
C1 --> C12[无锁队列]
C1 --> C13[顺序对象]
C1 --> C14[静止一致性]
C2 --> C21[静止一致性]
C2 --> C22[顺序一致性]
C2 --> C23[线性一致性]
C3 --> C31[并发对象实现优化]
C3 --> C32[并发编程挑战与解决方案]
C3 --> C33[未来发展趋势]
通过以上的分析和总结,我们可以看到并发编程是一个充满挑战和机遇的领域。在实际应用中,我们需要根据具体的需求和场景,选择合适的并发编程技术和算法,以实现高效、可靠的并发程序。
3008



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



