C++ `volatile` 关键字在多线程中的误用与正确理解

好的，没问题，直接进主题。

各位观众，今天咱们聊聊C++里那个让人又爱又恨的 volatile 关键字。说它让人爱吧，因为它看起来好像是解决多线程问题的神器；说它让人恨吧，因为它经常被误用，用了还不如不用，甚至更糟。今天咱们就扒一扒 volatile 在多线程环境下的那些事儿，争取让大家以后用得明白，用得放心。

volatile 是个啥？

首先，咱们得搞清楚 volatile 这哥们儿是干啥的。简单来说，volatile 告诉编译器：“嘿，老兄，这个变量的值可能会在你的控制之外发生改变，所以每次用它的时候都老老实实地从内存里读，别自作聪明地优化！”

举个例子：

#include <iostream>

int main() {
    volatile int x = 10;
    int y = x;
    std::cout << "x: " << x << std::endl; // 从内存读 x
    std::cout << "y: " << y << std::endl; // 从内存读 x
    std::cout << "x: " << x << std::endl; // 从内存读 x
    return 0;
}

在这个例子里，volatile 保证每次使用 x 的时候，程序都会乖乖地从内存里读取它的最新值，而不是直接使用之前缓存的值。如果没有 volatile，编译器可能会优化成只读一次 x 的值，然后直接用这个值来输出。

volatile 在单线程里干得挺好，到了多线程怎么就不灵了呢？

好，现在问题来了。volatile 在单线程里看起来挺靠谱的，能防止编译器过度优化。但是，一旦到了多线程环境，它就有点力不从心了。这是为啥呢？

主要原因在于，volatile 只能保证可见性 (Visibility)，但不能保证原子性 (Atomicity) 和顺序性 (Ordering)。

可见性 (Visibility): 这个 volatile 确实能保证，一个线程修改了变量的值，其他线程能够立即看到这个修改。但是，这仅仅是“看得到”，不代表“安全”。
原子性 (Atomicity): 原子性指的是一个操作是不可分割的。比如，x++ 看起来像一个操作，但实际上它包含了读取 x 的值、将 x 的值加 1、将结果写回 x 三个步骤。这三个步骤不是原子性的，在多线程环境下可能会被打断，导致数据竞争。volatile 无法保证 x++ 这样的操作是原子性的。
顺序性 (Ordering): 顺序性指的是程序执行的顺序。编译器和CPU为了提高效率，可能会对指令进行重排序。volatile 只能防止编译器对 volatile 变量相关的指令进行重排序，但不能防止 CPU 对指令进行重排序。而且，它也无法保证多个 volatile 变量之间的操作顺序。

举个栗子：volatile 的失效场景

假设有两个线程，一个线程负责写数据，一个线程负责读数据：

#include <iostream>
#include <thread>
#include <atomic> //引入atomic

volatile int data = 0;
volatile bool ready = false;

void writer_thread() {
    data = 42;
    ready = true;
    std::cout << "Writer: Data set to 42, ready is true" << std::endl;
}

void reader_thread() {
    while (!ready) {
        // 等待 ready 变为 true
    }
    std::cout << "Reader: Data is " << data << std::endl;
}

int main() {
    std::thread t1(writer_thread);
    std::thread t2(reader_thread);

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

    return 0;
}

你可能会觉得，这个程序应该能正确地输出 "Reader: Data is 42"。但是，实际运行结果可能会出乎你的意料。在某些情况下，reader 线程可能会在 ready 变为 true 之后，读取到的 data 仍然是 0。

原因分析：

虽然 volatile 保证了 ready 和 data 的可见性，但是它无法保证 data = 42; 和 ready = true; 这两个操作的顺序。编译器或 CPU 可能会对这两个操作进行重排序，导致 ready = true; 先于 data = 42; 执行。这样，reader 线程在 ready 变为 true 之后，读取到的 data 仍然是旧值。

volatile 什么时候有用？

说了这么多 volatile 的坏话，难道它就一无是处了吗？当然不是！volatile 在某些特定的场景下还是很有用的。

访问硬件寄存器: 嵌入式系统编程中，经常需要直接访问硬件寄存器。这些寄存器的值可能会随时发生改变，而且不是由程序控制的。这时候，volatile 就派上用场了，它可以防止编译器对这些寄存器的访问进行优化。
中断服务程序 (ISR): 中断服务程序是一种特殊的函数，它会在硬件中断发生时被调用。ISR 可能会修改一些全局变量，这些变量需要在主程序中被访问。这时候，volatile 可以保证主程序能够及时看到 ISR 对这些变量的修改。

多线程的正确姿势：原子操作、互斥锁、条件变量

既然 volatile 在多线程环境下靠不住，那我们应该用什么来解决多线程并发问题呢？答案是：原子操作、互斥锁、条件变量。

原子操作 (Atomic Operations): 原子操作是指不可分割的操作。C++11 提供了 <atomic> 头文件，其中包含了一系列原子类型和原子操作函数。原子操作可以保证多线程环境下的数据安全，而且通常比互斥锁的性能更好。

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

std::atomic<int> data(0);
std::atomic<bool> ready(false);

void writer_thread() {
    data = 42;
    ready = true;
    std::cout << "Writer: Data set to 42, ready is true" << std::endl;
}

void reader_thread() {
    while (!ready) {
        // 等待 ready 变为 true
    }
    std::cout << "Reader: Data is " << data << std::endl;
}

int main() {
    std::thread t1(writer_thread);
    std::thread t2(reader_thread);

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

    return 0;
}

在这个例子中，我们将 data 和 ready 声明为 std::atomic<int> 和 std::atomic<bool> 类型。这样，对 data 和 ready 的操作就变成了原子操作，可以保证多线程环境下的数据安全。

互斥锁 (Mutex): 互斥锁是一种同步机制，它可以防止多个线程同时访问共享资源。当一个线程获取了互斥锁之后，其他线程必须等待该线程释放锁才能访问共享资源。
```
#include <iostream>
#include <thread>
#include <mutex>

int data = 0;
bool ready = false;
std::mutex mtx;

void writer_thread() {
    std::lock_guard<std::mutex> lock(mtx);
    data = 42;
    ready = true;
    std::cout << "Writer: Data set to 42, ready is true" << std::endl;
}

void reader_thread() {
    while (true) {
        std::lock_guard<std::mutex> lock(mtx);
        if (ready) {
            std::cout << "Reader: Data is " << data << std::endl;
            break;
        }
    }
}

int main() {
    std::thread t1(writer_thread);
    std::thread t2(reader_thread);

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

    return 0;
}
```
在这个例子中，我们使用 std::mutex 来保护 data 和 ready 变量。writer 线程在修改 data 和 ready 之前，必须先获取互斥锁；reader 线程在读取 data 和 ready 之前，也必须先获取互斥锁。这样可以保证多个线程不会同时访问 data 和 ready，从而避免数据竞争。

std::lock_guard 是一个 RAII (Resource Acquisition Is Initialization) 风格的互斥锁包装器。它会在构造函数中获取互斥锁，在析构函数中释放互斥锁。这样可以保证互斥锁总是会被正确地释放，即使在发生异常的情况下。
条件变量 (Condition Variable): 条件变量是一种同步机制，它允许线程在满足特定条件之前进入休眠状态。当条件满足时，其他线程可以唤醒休眠的线程。
```
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

int data = 0;
bool ready = false;
std::mutex mtx;
std::condition_variable cv;

void writer_thread() {
    std::lock_guard<std::mutex> lock(mtx);
    data = 42;
    ready = true;
    std::cout << "Writer: Data set to 42, ready is true" << std::endl;
    cv.notify_one(); // 通知 reader 线程
}

void reader_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // 等待 ready 变为 true
    std::cout << "Reader: Data is " << data << std::endl;
}

int main() {
    std::thread t1(writer_thread);
    std::thread t2(reader_thread);

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

    return 0;
}
```
在这个例子中，我们使用 std::condition_variable 来让 reader 线程等待 ready 变为 true。writer 线程在设置 ready 为 true 之后，会调用 cv.notify_one() 来唤醒 reader 线程。

std::unique_lock 是一种比 std::lock_guard 更灵活的互斥锁包装器。它可以手动地获取和释放互斥锁，而且可以与条件变量一起使用。

cv.wait(lock, []{ return ready; }) 会原子地释放互斥锁，并将线程置于休眠状态，直到条件 ready 变为 true。当条件满足时，wait 函数会自动地重新获取互斥锁。

总结：volatile 的正确用法

特性	`volatile`	原子操作	互斥锁 + 条件变量
可见性	✔️	✔️	✔️
原子性	❌	✔️	✔️
顺序性	部分	✔️	✔️
适用场景	硬件寄存器、ISR	简单原子操作	复杂同步场景
性能	高	高	中
使用复杂度	低	中	高

记住，volatile 并不是解决多线程问题的银弹。在大多数情况下，你应该使用原子操作、互斥锁和条件变量来保证多线程环境下的数据安全。只有在访问硬件寄存器或 ISR 等特殊场景下，才应该考虑使用 volatile。

最后的忠告

多线程编程是一门复杂的艺术，需要深入理解并发的概念和原理。不要盲目地使用 volatile，要根据实际情况选择合适的同步机制。只有这样，才能写出安全、高效的多线程程序。

好了，今天的讲座就到这里。希望大家以后能够正确地使用 volatile，避免踩坑。谢谢大家！

发表回复 取消回复

发表回复取消回复