C++ `std::atomic_flag`：最轻量级的原子布尔标志

好了，各位听众，今天咱们来聊聊C++里一个不起眼，但关键时刻能救命的小家伙：std::atomic_flag。别看它名字里又是atomic又是flag的，好像很高大上，其实它干的事儿特别简单，就是一个原子布尔标志。但是，在并发编程的世界里，简单往往意味着高效。

啥是原子操作？为啥我们需要它？

首先，得先搞清楚啥是原子操作。想象一下，你在银行取钱，你输入密码，系统验证，然后钱从你的账户里扣掉，最后钱从ATM吐出来。这一系列操作必须是一个整体，要么全部完成，要么全部不完成。如果扣钱之后ATM突然坏了，没吐钱，那你就亏大了！这就是一个原子性的例子。

在计算机世界里，原子操作就是指一个操作要么完全执行，要么完全不执行，不会被其他线程打断。比如，一个简单的bool变量赋值，在多线程环境下可能就不是原子操作。为什么呢？因为赋值操作可能被分解成几个更小的指令，比如读取变量的地址、读取要赋的值、写入值。如果在执行这些指令的过程中，另一个线程也来修改这个变量，那结果就不可预测了，可能出现数据竞争，程序崩溃，或者更可怕的，出现一些莫名其妙的bug，让你抓破头皮都找不到原因。

这就是我们需要原子操作的原因。我们需要一种机制，保证在多线程环境下，对共享变量的操作是原子性的，不会被其他线程打断，保证数据的一致性。

std::atomic_flag：最轻量级的原子布尔标志

std::atomic_flag 是C++11引入的一个原子布尔标志，它是所有原子类型中，最最最基础的一个。它只有两个状态：设置 (set) 和清除 (clear)。它提供的操作也极其简单，只有两个：

test_and_set()：原子地设置标志为 true，并返回之前的值。
clear()：原子地清除标志为 false。

别看它简单，它可是构建更复杂的原子操作的基础。

为啥说它最轻量级？

std::atomic_flag之所以被称为最轻量级的原子类型，是因为它的设计目标就是尽可能地减少开销。它只需要能够原子地设置和清除标志，不需要提供其他复杂的原子操作，比如加减、比较交换等。这使得它在某些特定场景下，性能非常出色。

std::atomic_flag 的使用场景

自旋锁 (Spin Lock)

std::atomic_flag 最常见的用途就是实现自旋锁。自旋锁是一种忙等待的锁，线程会不断地检查锁是否可用，如果锁不可用，线程会一直循环等待，直到锁可用为止。

下面是一个使用 std::atomic_flag 实现自旋锁的例子：
```
#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

class SpinLock {
private:
    std::atomic_flag flag = ATOMIC_FLAG_INIT; // 初始化为未设置状态

public:
    void lock() {
        while (flag.test_and_set(std::memory_order_acquire)) {
            // 自旋等待锁释放
        }
    }

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

SpinLock lock;
int shared_data = 0;

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

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(increment);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "shared_data = " << shared_data << std::endl;
    return 0;
}
```
在这个例子中，SpinLock 类使用 std::atomic_flag 来实现锁的互斥访问。lock() 方法使用 test_and_set() 原子地设置标志，如果标志已经被设置，说明锁已经被其他线程持有，线程会一直自旋等待。unlock() 方法使用 clear() 原子地清除标志，释放锁。

内存顺序 (Memory Order)

在上面的代码中，我们使用了 std::memory_order_acquire 和 std::memory_order_release 这两个内存顺序。内存顺序指定了原子操作对内存的影响，以及不同线程之间内存访问的顺序。
- std::memory_order_acquire：获取内存屏障，保证在获取锁之后，所有后续的读操作都发生在锁释放之前。
- std::memory_order_release：释放内存屏障，保证在释放锁之前，所有之前的写操作都对其他线程可见。
使用正确的内存顺序非常重要，可以避免数据竞争和内存不一致的问题。

单例模式 (Singleton Pattern)

std::atomic_flag 也可以用来实现线程安全的单例模式。单例模式保证一个类只有一个实例，并且提供一个全局访问点。

#include <iostream>
#include <atomic>

class Singleton {
private:
    Singleton() {}
    static Singleton* instance;
    static std::atomic_flag flag;

public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* getInstance() {
        if (instance == nullptr) {
            if (!flag.test_and_set(std::memory_order_acquire)) {
                instance = new Singleton();
                std::atomic_thread_fence(std::memory_order_release); // 确保instance完全构造完成
                flag.clear(std::memory_order_release);
            } else {
                while (instance == nullptr) {
                    //自旋等待instance被构造
                }
            }
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton instance is doing something." << std::endl;
    }
};

Singleton* Singleton::instance = nullptr;
std::atomic_flag Singleton::flag = ATOMIC_FLAG_INIT;

int main() {
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();

    if (instance1 == instance2) {
        std::cout << "Both instances are the same." << std::endl;
    }

    instance1->doSomething();

    return 0;
}

在这个例子中，getInstance() 方法使用 std::atomic_flag 来保证只有一个线程可以创建 Singleton 实例。如果多个线程同时调用 getInstance() 方法，只有一个线程能够成功设置标志，并创建实例。其他线程会自旋等待，直到实例被创建完成。std::atomic_thread_fence保证了instance完全构造完成才对其他线程可见。

初始化标志 (Initialization Flag)

std::atomic_flag 也可以用来作为一个简单的初始化标志，用于指示某个操作是否已经执行过。

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

std::atomic_flag init_flag = ATOMIC_FLAG_INIT;
bool initialized = false;

void initialize() {
    if (!init_flag.test_and_set(std::memory_order_acquire)) {
        // 只有第一个线程能够执行初始化操作
        std::cout << "Initializing..." << std::endl;
        // 模拟初始化操作
        std::this_thread::sleep_for(std::chrono::seconds(1));
        initialized = true;
        init_flag.clear(std::memory_order_release);
        std::cout << "Initialization complete." << std::endl;
    } else {
        // 其他线程等待初始化完成
        while (!initialized) {
            std::this_thread::yield(); // 让出CPU时间片，避免过度占用CPU
        }
    }
}

void doSomething() {
    initialize();
    std::cout << "Doing something after initialization." << std::endl;
}

int main() {
    std::thread t1(doSomething);
    std::thread t2(doSomething);
    std::thread t3(doSomething);

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

    return 0;
}

在这个例子中，init_flag 用于保证 initialize() 函数只会被执行一次。如果多个线程同时调用 initialize() 函数，只有一个线程能够成功设置标志，并执行初始化操作。其他线程会等待，直到初始化完成。

std::atomic_flag 的局限性

虽然 std::atomic_flag 非常轻量级，但它也有一些局限性：

功能单一：只能设置和清除标志，不能进行其他原子操作。
没有 load() 操作：不能原子地读取标志的值。只能通过 test_and_set() 来间接获取之前的值。
可能导致忙等待：自旋锁会一直占用 CPU 资源，如果锁长时间不可用，会导致 CPU 资源浪费。

std::atomic_flag 和 std::atomic<bool> 的区别

你可能会问，既然有了 std::atomic_flag，为什么还要 std::atomic<bool> 呢？它们都是原子布尔类型，有什么区别？

特性	`std::atomic_flag`	`std::atomic<bool>`
功能	仅设置和清除	支持更多原子操作
操作	`test_and_set()`, `clear()`	`load()`, `store()`, `exchange()`, `compare_exchange_weak()`, `compare_exchange_strong()`
内存开销	通常更小	通常更大
应用场景	自旋锁，简单同步	更复杂的原子操作

简单来说，std::atomic_flag 更轻量级，适用于简单的同步场景，比如自旋锁。std::atomic<bool> 功能更强大，支持更多的原子操作，适用于更复杂的场景。

总结

std::atomic_flag 是C++并发编程工具箱里一个简单而强大的工具。它虽然功能单一，但却非常高效，可以用来实现自旋锁、单例模式、初始化标志等。了解它的特点和局限性，可以帮助你更好地选择合适的原子类型，编写高效的并发程序。

希望今天的讲解对大家有所帮助。记住，并发编程就像走钢丝，稍有不慎就会掉下去。但是，只要掌握了正确的工具和技巧，你就可以在并发的世界里自由翱翔！

发表回复 取消回复

发表回复取消回复