Peterson's Algorithm

Peterson's Algorithm

Peterson 算法是一种经典的软件实现的互斥算法,用于解决两个线程(或进程)并发访问共享资源时的临界区互斥问题。

它不依赖互斥锁、信号量等操作系统同步原语,而是通过两个共享变量来实现线程同步。

1. 核心思想

Peterson 算法使用两个共享变量:

bool flag[2] = {false, false};
int turn = 0;
  • flag[i]:表示线程 i 是否希望进入临界区。
  • turn:表示当两个线程都想进入临界区时,优先让哪个线程进入。

核心思想是:

先声明自己想进入临界区,再主动把优先权交给对方。

如果对方也想进入,就根据 turn 决定谁先进入。

2. 代码实现

下面是 Peterson 算法的经典伪代码(采用 C++ 风格):

bool flag[2] = {false, false};
int turn = 0;

void process(int i) {
    int j = 1 - i;

    while (true) {
        // 1. 表示自己想进入临界区
        flag[i] = true;

        // 2. 将优先权让给对方
        turn = j;

        // 3. 等待对方退出或轮到自己
        while (flag[j] && turn == j) {
            // 忙等待
        }

        // 4. 临界区
        // critical section

        // 5. 退出临界区
        flag[i] = false;

        // 非临界区
    }
}

注意:这是用普通变量表达算法逻辑的理论伪代码,不能直接作为现代 C++ 中线程安全的实现。实际 C++ 程序需要使用原子变量以及合适的内存序。

3. Peterson 算法执行过程

假设有两个线程 T0 和 T1。

情况一:只有 T0 想进入临界区

  1. T0 设置 flag[0] = true。
  2. T0 设置 turn = 1。
  3. T0 检查 flag[1] && turn == 1。
  4. 因为 flag[1] == false,所以条件不成立。
  5. T0 进入临界区。

结论: 当只有一个线程想进入时,不需要等待。

情况二:T0 和 T1 同时想进入临界区

假设执行顺序如下:

步骤 T0 T1
1 flag[0] = true
2 flag[1] = true
3 turn = 1
4 turn = 0
5 检查等待条件 检查等待条件

此时:

flag[0] = true;
flag[1] = true;
turn = 0;

T0 的判断:

while (flag[1] && turn == 1)

因为 turn == 0,条件不成立,T0 进入临界区。

T1 的判断:

while (flag[0] && turn == 0)

条件成立,T1 自旋等待。

当 T0 执行完毕:

flag[0] = false;

T1 的等待条件不再成立,于是进入临界区。

执行过程示意

假设 T1 最后修改 turn,T0 先进入临界区。

4. Peterson 算法满足的三个条件

经典临界区问题通常要求满足:

条件 含义 Peterson 算法
互斥性(Mutual Exclusion) 不允许两个线程同时进入临界区 满足
空闲让进(Progress) 临界区空闲时,想进入的线程能够进入 满足
有限等待(Bounded Waiting) 一个线程不能被另一个线程无限次插队 满足

这里的满足,是指在经典的顺序一致性模型以及线程持续获得执行机会等假设下成立。

为什么能保证互斥?

假设 T0 和 T1 同时处于临界区。

由于两者都还没有退出:

flag[0] == true;
flag[1] == true;

那么两个线程要通过等待条件,就必须分别满足:

T0 能进入:

turn != 1;  // 即 turn == 0

T1 能进入:

turn != 0;  // 即 turn == 1

同一时刻 turn 不可能同时等于 0 和 1。

因此产生矛盾,说明两个线程不可能同时进入临界区。

这就是 Peterson 算法保证互斥性的核心原理。

5. 现代 C++ 中如何实现?

在现代多核 CPU 中,普通变量可能受以下因素影响:

  • 编译器优化与指令重排。
  • CPU 的乱序执行和内存访问重排。
  • 多核之间的内存可见性。
  • C++ 普通共享变量并发读写引起的数据竞争(未定义行为)。

因此不能直接把经典伪代码用于实际多线程程序。

可以利用 std::atomic 和顺序一致性内存序实现:

#include <atomic>

class PetersonLock {
private:
    std::atomic<bool> flag[2]{
        false, false
    };

    std::atomic<int> turn{0};

public:
    void lock(int i) {
        int j = 1 - i;

        flag[i].store(
            true,
            std::memory_order_seq_cst
        );

        turn.store(
            j,
            std::memory_order_seq_cst
        );

        while (
            flag[j].load(
                std::memory_order_seq_cst
            ) &&
            turn.load(
                std::memory_order_seq_cst
            ) == j
        ) {
            // 自旋等待
        }
    }

    void unlock(int i) {
        flag[i].store(
            false,
            std::memory_order_seq_cst
        );
    }
};

其中:

memory_order_seq_cst 表示顺序一致性内存序,所有顺序一致性原子操作可以被视为存在一个共同的全局顺序,同时遵守各线程中的程序顺序。

这里采用最容易理解和推理的内存序。不能简单把它们全部改为 memory_order_relaxed,否则算法可能失去互斥保证。

另外,Peterson 算法本质上是一种自旋互斥机制,等待时会持续消耗 CPU。

6. Peterson 算法的缺点

  1. 只适用于两个参与者:经典 Peterson 算法是针对两个线程设计的,多线程需要进一步扩展,例如 Filter Lock。
  2. 忙等待:等待期间一直循环,占用 CPU。
  3. 实际性能不一定好:多个共享原子变量会产生缓存一致性流量,顺序一致性操作还可能带来额外开销。
  4. 不保证调度公平:理论上的有限等待不意味着操作系统一定会及时调度某个线程。
  5. 依赖正确的内存模型:不能直接用普通 C++ 变量实现。

因此在实际 C++ 开发中,通常优先使用 std::mutex,需要自旋锁时也通常采用适合目标硬件的原子操作实现。

7. Peterson 算法与其他互斥算法的区别

算法 核心机制 特点
严格轮流法 turn 变量 无法满足空闲让进
双标志先检查法 flag 变量 可能同时进入临界区
双标志后检查法 flag 变量 可能死锁
Peterson 算法 flag + turn 两线程互斥、避免经典死锁问题
Test-and-Set 自旋锁 硬件原子读改写 可用于多线程,可能竞争激烈
Mutex 原子操作 + 操作系统等待机制 适合通用线程同步
posted @ 2026-10-22 16:22  光風霽月  阅读(22)  评论(0)    收藏  举报