C++20原子引用：gh_mirrors/st/STL中的atomic_ref实现

郁音允Zoe

388人浏览 · 2025-10-17 08:40:42

郁音允Zoe · 2025-10-17 08:40:42 发布

C++20原子引用：gh_mirrors/st/STL中的atomic_ref实现

【免费下载链接】STL MSVC's implementation of the C++ Standard Library. 项目地址: https://gitcode.com/gh_mirrors/st/STL

在多线程编程中，我们经常需要处理共享数据的并发访问问题。传统的互斥锁机制虽然能保证线程安全，但往往会带来性能瓶颈。C++20标准引入了atomic_ref（原子引用）这一革命性特性，它允许我们以原子方式操作非原子对象，无需将对象本身声明为原子类型。本文将深入解析gh_mirrors/st/STL项目中atomic_ref的实现细节，帮助你理解这一高性能并发工具的工作原理和使用方法。

atomic_ref的核心价值与实现架构

atomic_ref的核心价值在于它能够将普通变量"原子化"，使多个线程可以安全地并发访问同一个非原子对象。与std::atomic相比，atomic_ref具有以下优势：

无需预先声明原子变量，降低了内存开销
可以对同一变量创建多个原子引用，提高了灵活性
支持更多类型的原子操作，包括用户自定义类型

在gh_mirrors/st/STL项目中，atomic_ref的实现主要集中在以下文件中：

头文件定义：stl/inc/atomic
内部实现细节：stl/inc/xatomic.h

实现架构概览

atomic_ref的实现采用了分层设计，主要包含以下几个部分：

接口层：定义在stl/inc/atomic中，提供符合C++标准的API
实现层：处理不同硬件架构的原子操作细节，如x86和ARM
工具层：提供内存屏障、锁机制等辅助功能

下面的类图展示了atomic_ref的核心结构：

mermaid

关键实现细节解析

内存模型与原子操作

C++内存模型定义了六种内存序（memory order），从弱到强依次为：relaxed、consume、acquire、release、acq_rel和seq_cst。gh_mirrors/st/STL中的实现严格遵循这一模型，在stl/inc/xatomic.h中定义了内存序的枚举类型：

enum memory_order {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
};

根据不同的硬件架构，实现层会选择合适的原子指令。例如，在x86架构上使用_Interlocked系列 intrinsic函数，而在ARM架构上则使用_INTRIN_ACQUIRE和_INTRIN_RELEASE宏来处理不同的内存序需求：

#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
#define _INTRIN_RELAXED(x) _CONCAT(x, _nf)
#define _INTRIN_ACQUIRE(x) _CONCAT(x, _acq)
#define _INTRIN_RELEASE(x) _CONCAT(x, _rel)
#define _INTRIN_ACQ_REL(x) x
#endif

无锁与有锁实现

atomic_ref的实现根据操作对象的大小和硬件支持情况，自动选择无锁或有锁实现。这一决策通过is_lock_free()方法暴露给用户。

无锁实现

对于硬件支持的原子操作，实现直接使用相应的指令。例如，在x86架构上，32位和64位整数的原子操作可以通过_Interlocked系列函数实现：

#define _ATOMIC_STORE_SEQ_CST_X86_X64(_Width, _Ptr, _Desired) \
    (void) _InterlockedExchange##_Width((_Ptr), (_Desired));

有锁实现

当硬件不支持特定大小的原子操作时，实现会退化为基于锁的方案。stl/inc/atomic中定义了_Atomic_lock_guard类来处理这种情况：

template <class _Spinlock_t>
class _NODISCARD _Atomic_lock_guard {
public:
    explicit _Atomic_lock_guard(_Spinlock_t& _Spinlock_) noexcept : _Spinlock(_Spinlock_) {
        _Atomic_lock_acquire(_Spinlock);
    }
    ~_Atomic_lock_guard() {
        _Atomic_lock_release(_Spinlock);
    }
private:
    _Spinlock_t& _Spinlock;
};

内存屏障与编译器优化

为了确保多线程环境下的内存可见性，atomic_ref的实现使用了内存屏障（memory barrier）技术。在stl/inc/xatomic.h中定义了不同硬件架构的内存屏障宏：

#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
#define _Memory_barrier()              __dmb(0xB) // inner shared data memory barrier
#define _Compiler_or_memory_barrier()  _Memory_barrier()
#define _Memory_load_acquire_barrier() __dmb(0x9) // inner shared data memory load barrier
#elif defined(_M_IX86) || defined(_M_X64)
#define _Compiler_or_memory_barrier() _Compiler_barrier()
#endif

同时，为了防止编译器优化导致的内存重排，实现中使用了_Compiler_barrier()宏：

#define _Compiler_barrier() _STL_DISABLE_DEPRECATED_WARNING _ReadWriteBarrier() _STL_RESTORE_DEPRECATED_WARNING

实际应用示例

基本用法

使用atomic_ref非常简单，只需将普通变量的引用传递给atomic_ref的构造函数即可：

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

int main() {
    int value = 0;
    std::atomic_ref<int> ref(value);
    
    std::thread t1([&ref]() {
        for (int i = 0; i < 1000; ++i) {
            ref.fetch_add(1, std::memory_order_relaxed);
        }
    });
    
    std::thread t2([&ref]() {
        for (int i = 0; i < 1000; ++i) {
            ref.fetch_add(1, std::memory_order_relaxed);
        }
    });
    
    t1.join();
    t2.join();
    std::cout << "Final value: " << value << std::endl; // 输出2000
    return 0;
}

自定义类型支持

atomic_ref不仅支持基本数据类型，还可以支持用户自定义类型，只要该类型满足"可平凡复制"（trivially copyable）的要求：

struct MyStruct {
    int a;
    long b;
};

MyStruct data = {0, 0};
std::atomic_ref<MyStruct> ref(data);

// 原子交换操作
MyStruct new_data = {1, 2};
MyStruct old_data = ref.exchange(new_data);

性能对比：atomic_ref vs mutex

为了展示atomic_ref的性能优势，我们可以对比它与传统互斥锁的性能差异：

#include <atomic>
#include <mutex>
#include <chrono>
#include <thread>
#include <vector>

const int THREADS = 8;
const int ITERATIONS = 1000000;

int main() {
    // 使用atomic_ref
    int counter1 = 0;
    std::atomic_ref<int> ref(counter1);
    auto start = std::chrono::high_resolution_clock::now();
    
    std::vector<std::thread> threads1;
    for (int i = 0; i < THREADS; ++i) {
        threads1.emplace_back([&ref]() {
            for (int j = 0; j < ITERATIONS; ++j) {
                ref.fetch_add(1, std::memory_order_relaxed);
            }
        });
    }
    
    for (auto& t : threads1) t.join();
    auto end = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    
    // 使用mutex
    int counter2 = 0;
    std::mutex mtx;
    start = std::chrono::high_resolution_clock::now();
    
    std::vector<std::thread> threads2;
    for (int i = 0; i < THREADS; ++i) {
        threads2.emplace_back([&counter2, &mtx]() {
            for (int j = 0; j < ITERATIONS; ++j) {
                std::lock_guard<std::mutex> lock(mtx);
                counter2++;
            }
        });
    }
    
    for (auto& t : threads2) t.join();
    end = std::chrono::high_resolution_clock::now();
    auto duration2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    
    std::cout << "atomic_ref: " << duration1 << "ms, result: " << counter1 << std::endl;
    std::cout << "mutex: " << duration2 << "ms, result: " << counter2 << std::endl;
    
    return 0;
}

在大多数情况下，atomic_ref会表现出明显的性能优势，特别是在高并发场景下。

深入理解内存序

内存序（memory order）是原子操作中一个非常重要但也容易混淆的概念。gh_mirrors/st/STL的实现严格遵循C++标准，提供了完整的内存序支持。

内存序的选择策略

在实际应用中，选择合适的内存序对性能有重要影响。一般来说，应该遵循"最小够用"原则：

relaxed：适用于计数器等无需同步的场景
acquire/release：适用于单生产者-单消费者模型
seq_cst：提供最强的同步保证，但性能开销最大

stl/inc/atomic中定义了内存序检查函数，确保使用有效的内存序：

extern "C" inline void _Check_memory_order(const unsigned int _Order) noexcept {
    if (_Order > _Atomic_memory_order_seq_cst) {
        _INVALID_MEMORY_ORDER;
    }
}

内存序组合逻辑

在实现复杂的原子操作（如compare_exchange_strong）时，需要组合不同的内存序。stl/inc/atomic中提供了_Combine_cas_memory_orders函数来处理这种情况：

_NODISCARD inline memory_order _Combine_cas_memory_orders(
    const memory_order _Success, const memory_order _Failure) noexcept {
    static constexpr memory_order _Combined_memory_orders[6][6] = {
        {memory_order_relaxed, memory_order_consume, memory_order_acquire, 
         memory_order_release, memory_order_acq_rel, memory_order_seq_cst},
        // ... 其他组合 ...
    };
    return _Combined_memory_orders[static_cast<int>(_Success)][static_cast<int>(_Failure)];
}

硬件架构适配

gh_mirrors/st/STL的atomic_ref实现充分考虑了不同硬件架构的特性，提供了针对性的优化。

x86架构支持

对于x86和x64架构，实现使用了_Interlocked系列 intrinsic函数：

#if (defined(_M_IX86) && !defined(_M_HYBRID_X86_ARM64)) || (defined(_M_X64) && !defined(_M_ARM64EC))
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
    _Check_memory_order(_Order);                                   \
    _Result = _Intrinsic(__VA_ARGS__)
#endif

ARM架构支持

对于ARM架构，实现使用了LDAR/STLR指令来支持获取-释放语义：

#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
#define _STD_ATOMIC_USE_ARM64_LDAR_STLR 1
#define __LOAD_ACQUIRE_ARM64(_Width, _Ptr) \
    static_cast<__int##_Width>(__load_acquire##_Width(reinterpret_cast<const volatile unsigned __int##_Width*>(_Ptr)))
#endif

跨平台内存屏障

内存屏障的实现也针对不同架构进行了优化，如stl/inc/xatomic.h所示：

#if defined(_M_ARM64) || defined(_M_ARM64EC) || defined(_M_HYBRID_X86_ARM64)
#define _Memory_barrier()              __dmb(0xB) // ARM架构
#elif defined(_M_IX86) || defined(_M_X64)
#define _Compiler_or_memory_barrier() _Compiler_barrier() // x86架构
#endif