C++如何使用std::atomic_flag实现轻量锁-C++-PHP中文网

C++如何使用std::atomic_flag实现轻量锁

P粉602998670

发布： 2025-09-12 10:43:01

原创

432人浏览过

std::atomic_flag通过原子操作实现轻量级自旋锁，适用于低竞争环境，其test_and_set()与clear()操作保证线程安全，配合memory_order可确保内存顺序，相比mutex减少系统开销，但高竞争下易导致CPU占用过高，可通过有限自旋或指数退避优化。

c++如何使用std::atomic_flag实现轻量锁

C++中使用

std::atomic_flag

登录后复制

实现轻量锁，本质上是利用原子操作来控制对共享资源的访问。它提供了一种简单、高效的方式来构建互斥锁，尤其适用于低竞争环境。

解决方案

std::atomic_flag

登录后复制

只有两个状态：设置（true）和清除（false）。它提供的基本操作是

test_and_set()

登录后复制

和

clear()

登录后复制

。

test_and_set()

登录后复制

原子地将 flag 设置为 true，并返回之前的值。

clear()

登录后复制

原子地将 flag 设置为 false。

下面是一个简单的使用

std::atomic_flag

登录后复制

实现自旋锁的例子：

立即学习“C++免费学习笔记（深入）”；

#include <iostream>
#include <atomic>
#include <thread>

class SpinLock {
public:
    SpinLock() : flag(ATOMIC_FLAG_INIT) {}

    void lock() {
        while (flag.test_and_set(std::memory_order_acquire));
    }

    void unlock() {
        flag.clear(std::memory_order_release);
    }

private:
    std::atomic_flag flag;
};

SpinLock spinlock;
int shared_data = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        spinlock.lock();
        shared_data++;
        spinlock.unlock();
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Shared data: " << shared_data << std::endl;
    return 0;
}

登录后复制

在这个例子中，

SpinLock

登录后复制

类使用

std::atomic_flag

登录后复制

来实现锁。

lock()

登录后复制

函数不断尝试设置 flag，直到成功为止。

unlock()

登录后复制

函数清除 flag，允许其他线程获取锁。

memory_order_acquire

登录后复制

和

memory_order_release

登录后复制

用于确保内存顺序，防止编译器或 CPU 重新排序操作。

为什么选择

std::atomic_flag

登录后复制

？

std::atomic_flag

登录后复制

通常比

std::mutex

登录后复制

更轻量级，因为它避免了操作系统级别的同步机制。在低竞争情况下，自旋锁的性能通常更好，因为它避免了线程上下文切换的开销。但是，在高竞争情况下，自旋锁可能会导致 CPU 占用率过高，因为线程会一直循环等待锁释放。

FashionLabs

AI服装模特、商品图，可商用，低价提升销量神器

查看详情

使用

std::atomic_flag

登录后复制

实现锁的优缺点是什么？

优点：
- 轻量级：避免了操作系统内核的参与，减少了开销。
- 适用于低竞争环境：在锁竞争不激烈的情况下，性能优于传统的互斥锁。
- 简单：API 简单，易于使用。
缺点：
- 高竞争环境下的性能问题：在高竞争环境下，自旋锁会消耗大量 CPU 资源。
- 可能导致死锁：如果线程在持有锁的情况下发生异常，可能会导致死锁。
- 缺乏公平性：自旋锁不保证线程获取锁的顺序，可能导致某些线程饥饿。

如何避免

std::atomic_flag

登录后复制

自旋锁的过度自旋？

在高竞争环境中，单纯的自旋锁会导致 CPU 资源浪费。可以通过以下方式来缓解这个问题：

有限自旋次数： 在自旋一段时间后，如果没有获取到锁，可以主动让出 CPU，例如调用
```
std::this_thread::yield()
```
登录后复制
。
指数退避： 每次自旋失败后，增加自旋的时间间隔，避免多个线程同时竞争。
结合futex： 使用用户态的futex机制，在自旋一定次数后，如果仍然未获取锁，则将线程放入等待队列，等待锁释放时再唤醒。

下面是一个使用有限自旋次数的例子：

void lock() {
    int spin_count = 0;
    while (flag.test_and_set(std::memory_order_acquire)) {
        if (spin_count > MAX_SPIN) {
            std::this_thread::yield(); // 让出 CPU
            spin_count = 0;
        }
        spin_count++;
    }
}

登录后复制