为何Clang会优化掉轮询其他线程写入变量的循环？

问题描述 #

学习C++时遇到异常现象：预期代码会输出一个较大数值（至少不是1.1），但实际结果并非如此。其他编译器表现符合预期，但开启激进优化的Clang编译器似乎直接跳过了while循环。疑问在于：代码是否存在问题，还是这是Clang的预期行为？

使用编译器：Apple Clang v14.0.3

代码示例 #

#include <iostream>
#include <thread>


static bool should_terminate = false;

void infinite_loop() {
    long double i = 1.1;
    while(!should_terminate)
        i *= i;
    std::cout << i;
}

int main() {
    std::thread(infinite_loop).detach();
    std::cout << "main thread";
    for (int i = 0 ; i < 5; i++) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << ".";
    }
    should_terminate = true;
}

Clang优化后的汇编结果（v16.0.0 -O3） #

_Z13infinite_loopv:                     # @_Z13infinite_loopv
        sub     rsp, 24
        fld     qword ptr [rip + .LCPI0_0]
        fstp    tbyte ptr [rsp]
        mov     rdi, qword ptr [rip + _ZSt4cout@GOTPCREL]
        call    _ZNSo9_M_insertIeEERSoT_@PLT
        add     rsp, 24
        ret

原因分析 #

这是Clang的合法优化行为，问题出在代码违反了C++内存模型规则，触发了未定义行为，使得编译器可以合法跳过while循环。

核心问题点：

• should_terminate是普通static bool变量，主线程的写入操作（should_terminate = true;）与子线程的读取操作（while(!should_terminate)）之间没有任何同步机制，属于数据竞争，这在C++标准中明确属于未定义行为。
• 编译器优化时会假设程序不存在未定义行为。由于子线程中没有同步操作，编译器判定should_terminate的值在子线程执行期间不会改变（初始值为false），因此while(!should_terminate)会被视为无限循环。
• 该循环的唯一操作是修改局部变量i，而i既没有被其他线程访问，也没有volatile修饰，循环本身没有任何可观察行为（如I/O、修改原子变量等）。根据C++标准，无观察行为的无限循环属于未定义行为，编译器可以任意修改这部分代码的行为——这里直接优化掉循环体，保留i的初始值1.1并输出。

解决方案 #

要修复问题，需保证线程间的变量可见性并消除数据竞争，可采用以下两种方式：

方式1：使用原子变量 #

将should_terminate声明为std::atomic<bool>，原子操作会自动保证线程间的可见性，同时避免数据竞争：

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

static std::atomic<bool> should_terminate = false;

void infinite_loop() {
    long double i = 1.1;
    // 使用memory_order_relaxed足够满足需求，也可使用默认的memory_order_seq_cst
    while(!should_terminate.load(std::memory_order_relaxed))
        i *= i;
    std::cout << i;
}

int main() {
    std::thread(infinite_loop).detach();
    std::cout << "main thread";
    for (int i = 0 ; i < 5; i++) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << ".";
    }
    should_terminate.store(true, std::memory_order_relaxed);
}

方式2：使用互斥锁 #

通过std::mutex保护对should_terminate的访问，确保读写操作的同步：

#include <iostream>
#include <thread>
#include <mutex>

static bool should_terminate = false;
static std::mutex mtx;

void infinite_loop() {
    long double i = 1.1;
    while(true) {
        std::lock_guard<std::mutex> lock(mtx);
        if(should_terminate) break;
        i *= i;
    }
    std::cout << i;
}

int main() {
    std::thread(infinite_loop).detach();
    std::cout << "main thread";
    for (int i = 0 ; i < 5; i++) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << ".";
    }
    std::lock_guard<std::mutex> lock(mtx);
    should_terminate = true;
}

内容的提问来源于stack exchange，提问作者ross1573