（86） 丰富了 atomic《bool》 功能的 原子标志类 atomic_flag 及其源码 ：
++ 给出其源码：
struct atomic_flag // flag with test-and-set semantics 带有测试和设置语义的标志
{
atomic<long> _Storage; // 本类的数据成员，存储 0 表 false， 1 表 true
constexpr atomic_flag() noexcept = default; // 默认的构造函数
#if _HAS_CXX20
bool test(const memory_order _Order = memory_order_seq_cst) const noexcept
{
return _Storage.load(_Order) != 0; // 若本类的数据成员不为 0 则返回 true
}
bool test(const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
return _Storage.load(_Order) != 0;
}
#endif // _HAS_CXX20
bool test_and_set(const memory_order _Order = memory_order_seq_cst) noexcept
{
return _Storage.exchange(true, _Order) != 0; // 设置本类的数据成员为 1 且返回旧值
}
bool test_and_set(const memory_order _Order = memory_order_seq_cst) volatile noexcept
{
return _Storage.exchange(true, _Order) != 0;
}
void clear(const memory_order _Order = memory_order_seq_cst) noexcept
{
_Storage.store(false, _Order); // 设置本类的数据成员为 0
}
void clear(const memory_order _Order = memory_order_seq_cst) volatile noexcept
{
_Storage.store(false, _Order);
}
#if _HAS_CXX20
void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
}
// wait(..) 是值不等于 形参 1 _Expected 才返回。
void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept
{
_Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
}
/*
template <class _Ty, size_t > // 泛化版本
struct _Atomic_storage
{ // 简单情况下 _Spinlock = long 类型。引用情况下 _Spinlock 是 void * 类型。
mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{}; // 定义了一个自旋锁
using _TVal = remove_reference_t<_Ty>;
_Ty _Storage{}; // 原子量要保护的数据成员，是个引用，也可以是一个值，都包括了
void wait(_TVal _Expected, memory_order = memory_order_seq_cst) const noexcept // 值不等于形参 1 才返回
{
const auto _Storage_ptr = _STD addressof(_Storage);
const auto _Expected_ptr = _STD addressof(_Expected);
for (;;) // 可见，wait（）被 nofify（）唤醒后，如果原子量的值等于形参 1，还是不会返回的。
{
{ _Guard _Lock{ _Spinlock }; // 取得自旋锁
if (_CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) != 0) return;
}
__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), &_Spinlock,
&_Atomic_wait_compare_non_lock_free<decltype(_Spinlock)>, _Atomic_wait_no_timeout);
}
}
};
*/
void notify_one() noexcept { _Storage.notify_one(); }
void notify_one() volatile noexcept { _Storage.notify_one(); }
void notify_all() noexcept { _Storage.notify_all(); }
void notify_all() volatile noexcept { _Storage.notify_all(); }
#endif // _HAS_CXX20
};
（87） 本 《 atomic 》 头文件的源代码汇总如下，总共 3600 行，带比较详细的注释。最后的 600 行关于原子量 atomic 系列的全局函数，不实用，其实现依然是依赖于原子模板类的成员函数，故不再详细注释这些全局函数：
// atomic standard header
// Copyright (c) Microsoft Corporation.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#pragma once
#ifndef _ATOMIC_
#define _ATOMIC_
#include <yvals.h>
#if _STL_COMPILER_PREPROCESSOR
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <xatomic.h>
#if _HAS_CXX20
#include <xatomic_wait.h>
#endif // _HAS_CXX20
#include <xthreads.h>
#pragma pack(push, _CRT_PACKING)
// 以下的结构体以及 union 将采用 8 字节对齐。入栈原来的对齐方式 _CRT_PACKING = 8
#pragma warning(push, _STL_WARNING_LEVEL)
// 调整本源文件编译时候的警告级别，是较减少了警告。 _STL_WARNING_LEVEL = 3
// 0 不警告，4 全警告。并把原来的警告级别入栈
#pragma warning(disable : _STL_DISABLED_WARNINGS)
// #define _STL_DISABLED_WARNINGS 4180 4412 4455 4494 4514 4574 ......
// 表示禁用这些警告，忽略这些警告 <yvals_core.h>
_STL_DISABLE_CLANG_WARNINGS
// 按字面意思，禁止 clang 警告，最后还有对应的 宏定义，_STL_RESTORE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new
// 入栈系统之前的 new 的宏定义，并取消此宏定义。可能要自己定义内存管理方式
//************************************************************************************************
#define _Compiler_barrier() _STL_DISABLE_DEPRECATED_WARNING _ReadWriteBarrier() _STL_RESTORE_DEPRECATED_WARNING
// 此处注释做了删减，识别 CPU 硬件，本主机是常见 intel i5 64 位CPU
#if defined(_M_IX86) || defined(_M_X64)
// x86/x64 hardware only emits memory barriers inside _Interlocked intrinsics
// x86/x64硬件仅在_Interlocked内置程序内部释放内存障碍。
#define _Compiler_or_memory_barrier() _Compiler_barrier()
#endif // hardware
// 从颜色看:此处本机确保定义了宏 _INVALID_MEMORY_ORDER：功能是报告错误
#ifndef _INVALID_MEMORY_ORDER
#ifdef _DEBUG
#define _INVALID_MEMORY_ORDER _STL_REPORT_ERROR("Invalid memory order")
#endif // _DEBUG
#endif // _INVALID_MEMORY_ORDER
// 这是 W64 系统上的特殊处理
#ifdef _WIN64
#if _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B == 1
#else // 此宏 = 0,所以只看 else 部分，意思是本主机 CPU 没有 cmpxchg16b 这一原子指令
extern "C" _NODISCARD unsigned char __stdcall __std_atomic_compare_exchange_128(
_Inout_bytecount_(16) long long* _Destination,
_In_ long long _ExchangeHigh, // 看起来是旧主机用一个函数来完成 16 字节的原子交换操作
_In_ long long _ExchangeLow , // 以替换和实现 cmpxchg16b 指令的功能
_Inout_bytecount_(16) long long* _ComparandResult) noexcept;
extern "C" _NODISCARD char __stdcall __std_atomic_has_cmpxchg16b() noexcept;
#define _STD_COMPARE_EXCHANGE_128 __std_atomic_compare_exchange_128
#endif // _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B == 1
#endif // _WIN64
// X64 主机，但没有 cmpxchg16b 这一原子指令，则定义下面的宏
#define _ATOMIC_HAS_DCAS 0
// x64 平台上定义这个可变参函数
#if defined(_M_IX86) || (defined(_M_X64) && !defined(_M_ARM64EC))
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
#endif // hardware
#define ATOMIC_BOOL_LOCK_FREE 2
#define ATOMIC_CHAR_LOCK_FREE 2
#define ATOMIC_CHAR16_T_LOCK_FREE 2
#define ATOMIC_CHAR32_T_LOCK_FREE 2
#define ATOMIC_WCHAR_T_LOCK_FREE 2
#define ATOMIC_SHORT_LOCK_FREE 2
#define ATOMIC_INT_LOCK_FREE 2
#define ATOMIC_LONG_LOCK_FREE 2
#define ATOMIC_LLONG_LOCK_FREE 2
#define ATOMIC_POINTER_LOCK_FREE 2
#ifdef __cpp_lib_char8_t
#define ATOMIC_CHAR8_T_LOCK_FREE 2
#endif // __cpp_lib_char8_t
_EXTERN_C //= extern "C" { 声明了一个外部的 C 函数
_Smtx_t* __stdcall __std_atomic_get_mutex(const void* _Key) noexcept;
_END_EXTERN_C //= }
// 本主机上开启了 c++20 ，但 __EDG__ = 1，所以执行 else
#if _HAS_CXX20 && !defined(__clang__) && !defined(__EDG__)
#else
#define _CMPXCHG_MASK_OUT_PADDING_BITS 0
#endif
_STD_BEGIN
// #define _STD_BEGIN namespace std { 表示以下内容全部定义于 std 命名空间
//******************************************开始 c++ 代码********************************************
//*********************************以下是关于内存约束的函数********************************************
// implement memory barrier for atomic load functions 为原子读函数的操作设置内存栅栏
inline void _Load_barrier(const memory_order _Order)
{
switch (_Order)
{
case memory_order_relaxed: break; // no barrier 此情形最松散，不进行内存约束
default:
case memory_order_release: // 3
case memory_order_acq_rel: _INVALID_MEMORY_ORDER; // 4，[[fallthrough]]; 这两种情况会报错
case memory_order_consume: // 1
case memory_order_acquire: // 2 此宏定义在本文件上面
case memory_order_seq_cst: // _Compiler_or_memory_barrier() = _Compiler_barrier()
_Compiler_or_memory_barrier();
break;
}
}
//***********************************
// enum class memory_order : int { relaxed, consume, acquire, release, acq_rel, seq_cst };
extern "C" inline void atomic_thread_fence(const memory_order _Order) // fence 屏障围栏栅栏
{
if (_Order == memory_order_relaxed) return; // 宽松的内存顺序约束,不做任何处理
#if defined(_M_IX86) || defined(_M_X64)
_Compiler_barrier();
if (_Order == memory_order_seq_cst) // 最严格的内存同步
{
volatile long _Guard;
#pragma warning(suppress : 6001 ) // 禁用了两个编译警告
#pragma warning(suppress : 28113)
(void) _InterlockedIncrement(&_Guard); //对变量执行原子自增操作
_Compiler_barrier();
}
#endif
}
extern "C" inline void atomic_signal_fence(const memory_order _Order) // 信号栅栏
{
if (_Order != memory_order_relaxed) // 本函数是用于涉及信号处理函数的内存同步
_Compiler_barrier();
}
//**************************************
// enum class memory_order : int { relaxed0, consume1, acquire2, release3, acq_rel4, seq_cst5 };
inline void _Check_memory_order(const memory_order _Order) noexcept
{
// check that _Order is a valid memory_order 检查形参 _Order 是否为有效的内存序
if (static_cast<unsigned int>(_Order) > static_cast<unsigned int>(memory_order_seq_cst))
_INVALID_MEMORY_ORDER; // 报错的意思
// #define _INVALID_MEMORY_ORDER = _STL_REPORT_ERROR("Invalid memory order")
}
// enum class memory_order : int { relaxed0, consume1, acquire2, release3, acq_rel4, seq_cst5 };
inline void _Check_store_memory_order(const memory_order _Order) noexcept
{
switch (_Order) // 顾名思义：检查写的内存序
{
case memory_order_relaxed: // 最宽松的内存顺序约束，叫自由序 0
case memory_order_release: // 发布 与 acquire 配合使用，叫获取释放序，被允许 3
case memory_order_seq_cst: // 最严格，顺序一致性。被允许 5
// nothing to do
break;
case memory_order_consume: // 太复杂，已被 c++17 弃用 1
case memory_order_acquire: // 接收 2
case memory_order_acq_rel: // 同时具备 rel 和 acq 的功能 4
default:
_INVALID_MEMORY_ORDER; // 后三种内存序，不准被用于写
break;
}
}
inline void _Check_load_memory_order(const memory_order _Order) noexcept
{
switch (_Order) // 顾名思义：检查读操作的内存序
{
case memory_order_relaxed: // 允许 0
case memory_order_consume: // 允许 1
case memory_order_acquire: // 允许 2
case memory_order_seq_cst: // 允许 5
// nothing to do
break;
case memory_order_release:
case memory_order_acq_rel:
default:
_INVALID_MEMORY_ORDER;
break;
}
}
//***********************************
// Finds upper bound of a compare/exchange memory order pair, according to the following partial order:
// 查找上界，根据以下部分顺序比较 / 交换内存订单对
// seq_cst 5
// | |
// acq_rel 4
// / \ / \
// acquire release 2 3
// | | | |
// consume | 1 |
// \ / \ /
// relaxed 0
//
// 下面函数里的二维数组里就是这些内容： _Success 是横坐标，_Failure 是纵坐标
// 0 0 1 2 3 4 5
// 1 1 1 2 4 4 5
// 2 2 2 2 4 4 5
// 3 3 4 4 3 4 5
// 4 4 4 4 4 4 5
// 5 5 5 5 5 5 5
//
// enum class memory_order : int { relaxed0, consume1, acquire2, release3, acq_rel4, seq_cst5 };
inline memory_order _Combine_cas_memory_orders( const memory_order _Success, const memory_order _Failure)
{
static constexpr memory_order _Combined_memory_orders[6][6] = {// combined upper bounds
{memory_order_relaxed, memory_order_consume, memory_order_acquire,
memory_order_release, memory_order_acq_rel, memory_order_seq_cst},
{memory_order_consume, memory_order_consume, memory_order_acquire,
memory_order_acq_rel, memory_order_acq_rel, memory_order_seq_cst},
{memory_order_acquire, memory_order_acquire, memory_order_acquire,
memory_order_acq_rel, memory_order_acq_rel, memory_order_seq_cst},
{memory_order_release, memory_order_acq_rel, memory_order_acq_rel,
memory_order_release, memory_order_acq_rel, memory_order_seq_cst},
{memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel,
memory_order_acq_rel, memory_order_acq_rel, memory_order_seq_cst},
{memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst,
memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst} };
_Check_memory_order(_Success);
_Check_load_memory_order(_Failure);
return _Combined_memory_orders[static_cast<int>(_Success)][static_cast<int>(_Failure)];
}
//********************************以下是两个转换数据类型的函数*****************************************
// "magic" template that kills dependency ordering when called
// "magic"模板，在调用时会杀死依赖项排序
// 本函数的功能似乎是接受任意类型的形参值并作为函数的返回值而已。
template <class _Ty>
_Ty kill_dependency(_Ty _Arg) noexcept { return _Arg; }
//******************************
// interprets _Source as the supplied integral type 将 _Source 解释为提供的整型类型
template <class _Integral, class _Ty> // 本函数只允许往内存变大或相等的方向转换类型
_Integral _Atomic_reinterpret_as(const _Ty& _Source) noexcept // 不允许缩小内存范围
{
// 静态断言要求条件为真才继续执行代码：要求模板参数一是某种整数类型
static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
if constexpr (is_integral_v<_Ty> && sizeof(_Integral) == sizeof(_Ty))
return static_cast<_Integral>(_Source); // 同内存大小的俩整数之间的转换
else if constexpr (is_pointer_v<_Ty> && sizeof(_Integral) == sizeof(_Ty))
return reinterpret_cast<_Integral>(_Source); // 同内存大小的把指针转换为整型数据
else
{
_Integral _Result{}; // zero padding bits 用 0 初始化整型数据
_CSTD memcpy(&_Result, _STD addressof(_Source), sizeof(_Source));
// void* memcpy( void* _Dst, void const* _Src, size_t _Size );
// 经过测试，大内存往小内存里复制数据，本 memcpy 函数会直接报错
return _Result;
}
}
//****************************************以下是线程同步的全局函数*******************************************
template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)> // 模板类的前向声明，下面要用
struct _Atomic_storage;
#if _HAS_CXX20
template <class _Ty, class _Value_type> // 本函数会让本线程睡眠等待，直到形参 1 和 2 不等才返回
void _Atomic_wait_direct // 更准确的描述是等待原子量(形参1 ) 发生变化后才返回
( const _Atomic_storage<_Ty>* const _This, _Value_type _Expected_bytes, const memory_order _Order )
{
const auto _Storage_ptr = _STD addressof(_This->_Storage); // 形参2 可以是原子量形参1 的原本的值
for (;;)
{
// template <class _Integral, class _Ty> // 本函数只允许往内存变大或相等的方向转换类型
// _Integral _Atomic_reinterpret_as(const _Ty & _Source) noexcept // 不允许缩小内存范围
const _Value_type _Observed_bytes = _Atomic_reinterpret_as<_Value_type>(_This->load(_Order));
if (_Expected_bytes != _Observed_bytes) return; // 由下面的函数完成本函数的主要语义
// int __std_atomic_wait_direct( void* _Storage, void* _Comparand, size_t _Size, u_long _Remaining_timeout)
__std_atomic_wait_direct(_Storage_ptr, &_Expected_bytes, sizeof(_Value_type), _Atomic_wait_no_timeout);
// unsigned long _Atomic_wait_no_timeout = 0xFFFF'FFFF; // Pass as partial timeout
}
}
#endif // _HAS_CXX20
//******************************************
// 本函的语义是让本线程执行忙等待，直到形参的值为 0 才返回。
// 函数名顾名思义：原子性的获取锁。形参就是锁，形参值为0 表示锁空闲。
inline void _Atomic_lock_acquire(long& _Spinlock) noexcept // 本函有删减,仅仅适用于 intel CPU
{
#if defined(_M_IX86) || (defined(_M_X64) && !defined(_M_ARM64EC))
int _Current_backoff = 1 ; // 这里是定义了一个偏移量
const int _Max_backoff = 64 ; // 随后每次都让 _Current_backoff 的值左移一位，增加 2 倍
// LONG _InterlockedExchange( LONG volatile* Target, LONG Value ); windows 平台的原子函数
// 原子性的把形参 2 赋值给形参 1，并返回形参 1 里的旧值。本函数只操作 32 bit 的数据
while (_InterlockedExchange(&_Spinlock, 1) != 0) // 外层循环只执行一次，自旋锁为 0 则同时结束内外循环
{
// 已知 int a = 3 ; int& b = a; 经测试：对左值引用取地址 &b 返回的是原始变量 a 的地址
// uint32_t __iso_volatile_load32(const volatile uint32_t *addr); 从形参地址里原子性的读取一个值
while (__iso_volatile_load32(&reinterpret_cast<int&>(_Spinlock)) != 0)
{
for (int _Count_down = _Current_backoff; _Count_down != 0; --_Count_down)
_mm_pause(); // 此函数是为了让 X86 x64 平台上的 CPU 执行低功耗的、低频率的忙等待
_Current_backoff = _Current_backoff < _Max_backoff ? _Current_backoff << 1 : _Max_backoff;
}
}
#endif
}
inline void _Atomic_lock_acquire(_Smtx_t* _Spinlock) noexcept // 重载函数,功能肯定是一样的
{
_Smtx_lock_exclusive(_Spinlock); // using _Smtx_t = void*;
}
//************************************
// 顾名思义：这俩函数是原子性的释放锁，赋值形参锁为 0 值。
inline void _Atomic_lock_release(long& _Spinlock) noexcept // 本函有删减,仅仅适用于 intel CPU
{
#if defined(_M_IX86) || (defined(_M_X64) && !defined(_M_ARM64EC))
_InterlockedExchange(&_Spinlock, 0);
#endif
}
inline void _Atomic_lock_release(_Smtx_t* _Spinlock) noexcept // 函数重载，32 位版本与 64 位版本
{
_Smtx_unlock_exclusive(_Spinlock); // 上面的函数更容易理解
}
//************************************
#if _HAS_CXX20
// 本函数在获取锁 _Spinlock_raw 以后，原子性的比较地址 _Storage 与地址 _Comparand 处
// 开始的 _Size 个字节的数据是否相等。是则返回 true，不等返回 fasle。
// 本函数的功能是给普通的比较函数 memcmp(..) 加上了原子保护。
template <class _Spinlock_t>
bool __stdcall _Atomic_wait_compare_non_lock_free // 本函数调用了上面的俩锁等待与锁释放函数
( const void* _Storage, void* _Comparand, size_t _Size, void* _Spinlock_raw) noexcept
{
_Spinlock_t& _Spinlock = *static_cast<_Spinlock_t*>(_Spinlock_raw); // 转换成模板参数的类型
_Atomic_lock_acquire(_Spinlock); // 忙等待，以获得自旋锁的使用权
const auto _Cmp_result = _CSTD memcmp(_Storage, _Comparand, _Size); // 内存中的数据比较
//int memcmp( void const* _Buf1, void const* _Buf2, size_t _Size );相等返回 0
_Atomic_lock_release(_Spinlock); // 释放自旋锁
return _Cmp_result == 0; // 形参 1 和 2 相等则返回 true 。
}
// 本函数适用于低版本的 x64 CPU 上运行 win64 系统，而没有 cmpxchg16b 指令的情形。
// 本函把 16 字节的形参1 与形参 2 交换，交换成功则返回 true。
inline bool __stdcall _Atomic_wait_compare_16_bytes
(const void* _Storage, void* _Comparand, size_t, void*) noexcept
{
const auto _Dest = static_cast<long long*>(const_cast<void*>(_Storage));
const auto _Cmp = static_cast<const long long*>(_Comparand);
alignas(16) long long _Tmp[2] = {_Cmp[0], _Cmp[1]};
return _STD_COMPARE_EXCHANGE_128(_Dest, _Tmp[1], _Tmp[0], _Tmp) != 0;
/*
// 看起来是旧主机用一个函数来完成 16 字节的原子交换操作,以替换和实现 cmpxchg16b 指令的功能。
u_char __std_atomic_compare_exchange_128
( long long* Destination, long long ExchangeHigh, long long ExchangeLow , long long* ComparandResult);
#define _STD_COMPARE_EXCHANGE_128 __std_atomic_compare_exchange_128
*/
}
#endif // _HAS_CXX20
//************************************以下是一些小型的结构体定义****************************************
template <class _Ty> // uninitialized space to store a _Ty
struct _Storage_for // 本模板类用一块未初始化的空间存储 _Ty 类型的数据
{
alignas(_Ty) unsigned char _Storage[sizeof(_Ty)]; // 本类的数据成员
_Storage_for() = default; // 默认的构造函数
_Storage_for(const _Storage_for&) = delete; // 禁止 copy 构造函数
_Storage_for& operator=(const _Storage_for&) = delete; // 禁止 copy 赋值运算符函数
_Ty& _Ref() { return reinterpret_cast<_Ty&>(_Storage); } // 返回对本类数据成员的引用
_Ty* _Ptr() { return reinterpret_cast<_Ty*>(&_Storage); } // 返回本类中数据成员的地址
};
//******************************
// align to sizeof(T); x86 stack aligns 8-byte objects on 4-byte boundaries
template <class _Ty> // 对齐sizeof (T);x86堆栈在4字节边界上对齐8字节对象
struct _Atomic_padded { alignas(sizeof(_Ty)) mutable _Ty _Value; };
//******************************
template <class _Ty> // 泛化模板
struct _Atomic_storage_types
{
using _TStorage = _Atomic_padded<_Ty>; // 简写了上面的类型
using _Spinlock = long; // 看起来是自旋锁的意思
};
template <class _Ty> // 特化模板
struct _Atomic_storage_types<_Ty&>
{
using _TStorage = _Ty&; // 相对于泛化版本，修改了此类型为左值引用
using _Spinlock = _Smtx_t*; // POINTER TO mutex ; using _Smtx_t = void* 指针类型
};
//********************************
template <class _Spinlock_t> // 锁的保卫，以防止忘记释放锁
class _Atomic_lock_guard
{
private:
_Spinlock_t& _Spinlock; // 数据成员是对自旋锁的左值引用
public:
explicit _Atomic_lock_guard(_Spinlock_t& _Spinlock_) noexcept // 有参构造函数
: _Spinlock(_Spinlock_)
{
_Atomic_lock_acquire(_Spinlock); // 直到获得此自旋锁，构造函数才返回
}
_Atomic_lock_guard(const _Atomic_lock_guard&) = delete; // 禁止 copy 构造函数
_Atomic_lock_guard& operator=(const _Atomic_lock_guard&) = delete; // 禁止 copy 赋值运算符函数
~_Atomic_lock_guard() { _Atomic_lock_release(_Spinlock); } // 析构函数，释放自旋锁
};
//****************************以下介绍基类 _Atomic_storage<T,U> 及其特化版本**********************************
/*
template <class _Ty> // 对齐sizeof (T);x86堆栈在4字节边界上对齐8字节对象
struct _Atomic_padded
{ alignas(sizeof(_Ty)) mutable _Ty _Value; };
template <class _Ty>
struct _Atomic_storage_types {
using _TStorage = _Atomic_padded<_Ty>;
using _Spinlock = long;
};
template <class _Ty>
struct _Atomic_storage_types<_Ty&> {
using _TStorage = _Ty&;
using _Spinlock = _Smtx_t*; // POINTER TO mutex
};
//-----------------------------------------------------------------------------
template <class _Ty, size_t >
struct _Atomic_storage // 分析此版本得了
{ _Ty _Storage{}; };
template <class _Ty>
struct _Atomic_storage<_Ty, 1> // 还有 2 4 8 16 的重载
{ typename _Atomic_storage_types<_Ty>::_TStorage _Storage; };
template <class _Ty, size_t = sizeof(_Ty)> // 还有 1 2 4 8 的重载，但其泛化版本无定义
struct _Atomic_integral : _Atomic_storage<_Ty> {};
template <class _Ty> // 本模板作为普通整形 atomic<int> 的父类 ,本类并无数据成员
struct _Atomic_integral_facade : _Atomic_integral<_Ty>{ };
template <class _Ty> // atomic value
struct atomic : _Choose_atomic_base_t<_Ty>{};
*/
template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)> // 模板类的前向声明，下面要用
struct _Atomic_storage;
template <class _Ty, size_t > // 第二个普通模板参数是有默认值的
struct _Atomic_storage // 非类型模板参数，必须在编译时是已知的常量表达式
{
private:
// 简单情况下 _Spinlock = long 类型。引用情况下 _Spinlock 是 void * 类型。
mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{}; // 定义了一个自旋锁
protected: // 此函是为了初始化 _Ty 是引用类型的情况，调用的函数的定义在本文最上面
void _Init_spinlock_for_ref() { _Spinlock = __std_atomic_get_mutex(_STD addressof(_Storage)); }
public:
_Ty _Storage{}; // 原子量要保护的数据成员，是个引用，也可以是一个值，都包括了
using _TVal = remove_reference_t<_Ty>;
using _Guard = _Atomic_lock_guard<typename _Atomic_storage_types<_Ty>::_Spinlock>; //锁的 guard
_Atomic_storage() = default; // 默认构造函数
_Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) // 有参构造函数
: _Storage(_Value) { }
void notify_one() { __std_atomic_notify_one_indirect(_STD addressof(_Storage)); } // 搭配 wait(..) 使用
void notify_all() { __std_atomic_notify_all_indirect(_STD addressof(_Storage)); }
void store(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) // 存入值
{
_Check_store_memory_order(_Order); // 允许的写入内存序：relaxed、release、seq_cst
_Guard _Lock{ _Spinlock }; // 先获取自旋锁，再存入数据，这就是原子量的来源
_Storage = _Value;
}
_TVal load(const memory_order _Order = memory_order_seq_cst) const noexcept // 读取值
{
_Check_load_memory_order(_Order); // 允许的读取内存序：relaxed、acquire、seq_cst
_Guard _Lock{ _Spinlock }; // 先获取自旋锁，再读取数据
_TVal _Local(_Storage);
return _Local; // 返回值是值传递
}
_TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept
{
_Check_memory_order(_Order); // 要求形参是 0~5 中的任意一种内存序即可
_Guard _Lock{ _Spinlock };
_TVal _Result(_Storage);
_Storage = _Value;
return _Result; // 把新值 _Value 存入本模板中，并把保存的旧值返回
}
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // 注意：形参1 是左值引用，对左值引用取地址返回的是原始值的地址
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
_Check_memory_order(_Order);
const auto _Storage_ptr = _STD addressof(_Storage ); // 取本类中数据成员的地址
const auto _Expected_ptr = _STD addressof(_Expected);
bool _Result;
_Guard _Lock{ _Spinlock }; // 取得自旋锁
_Result = _CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
if (_Result)
_CSTD memcpy(_Storage_ptr , _STD addressof(_Desired), sizeof(_TVal));
else
_CSTD memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
return _Result;
}
void wait(_TVal _Expected, memory_order = memory_order_seq_cst) const noexcept // 值不等于形参 1 才返回
{
const auto _Storage_ptr = _STD addressof(_Storage );
const auto _Expected_ptr = _STD addressof(_Expected);
for (;;) // wait（）被 nofify（）唤醒后，如果原子量的值等于形参 1，还是不会返回的。
{
{ _Guard _Lock{ _Spinlock }; // 取得自旋锁
if (_CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) != 0) return;
}
__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), &_Spinlock,
&_Atomic_wait_compare_non_lock_free<decltype(_Spinlock)>, _Atomic_wait_no_timeout);
}
}
};
//************以下是一个特化模板************
template <class _Ty> // lock-free using 1-byte intrinsics，无锁，使用 1 字节内置函数
struct _Atomic_storage<_Ty, 1> // 本特化版本，缺少了内置的自旋锁的数据成员，效率更高
{
typename _Atomic_storage_types<_Ty>::_TStorage _Storage; // 保存了一个值或是左值引用
/*
template <class _Ty> // 这个特化版本的数据成员的定义，也不同于其泛化版本
struct _Atomic_padded { alignas(sizeof(_Ty)) mutable _Ty _Value; };
template <class _Ty>
struct _Atomic_storage_types { using _TStorage = _Atomic_padded<_Ty>; };
template <class _Ty>
struct _Atomic_storage_types<_Ty&> { using _TStorage = _Ty&; };
*/
using _TVal = remove_reference_t<_Ty>;
_Atomic_storage() = default; // 默认构造函数
// non-atomically initialize this atomic
_Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) // 有参构造函数
: _Storage{_Value} { }
// template <class _Ty, class _Value_type> 本函数会让本线程睡眠等待，直到形参 1 和 2 不等才返回
// void _Atomic_wait_direct 更准确的描述是等待原子量(形参1 ) 发生变化后才返回
// ( _Atomic_storage<_Ty>* this, _Value_type expected_bytes, memory_order order)
// 所以，本成员函数的语义是等待本类的数据成员与形参 1 不等才返回。
void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst)
{
_Atomic_wait_direct(this, _Atomic_reinterpret_as<char>(_Expected), _Order);
}
void notify_one() { __std_atomic_notify_one_direct(_STD addressof(_Storage)); }
void notify_all() { __std_atomic_notify_all_direct(_STD addressof(_Storage)); }
/*
template <class _Integral, class _Ty> // 本函返回形参引用的原始数据的地址
volatile _Integral* _Atomic_address_as(_Ty& _Source) // 本函数是精简版
{ return &reinterpret_cast<volatile _Integral&>(_Source); }
*/
void store(const _TVal _Value) noexcept // store with sequential consistency 函数重载
{
const auto _Mem = _Atomic_address_as<char>(_Storage);
const char _As_bytes = _Atomic_reinterpret_as<char>(_Value);
(void) _InterlockedExchange8(_Mem, _As_bytes);
}
void store(const _TVal _Value, const memory_order _Order) noexcept // store with given memory order
{
const auto _Mem = _Atomic_address_as<char>(_Storage);
const char _As_bytes = _Atomic_reinterpret_as<char>(_Value);
switch (_Order)
{
case memory_order_relaxed:
__iso_volatile_store8(_Mem, _As_bytes); return;
case memory_order_release:
_Compiler_or_memory_barrier(); // _Compiler_or_memory_barrier() = _Compiler_barrier()
__iso_volatile_store8(_Mem, _As_bytes);
return;
default:
case memory_order_consume: // 以下几种内存序违法
case memory_order_acquire:
case memory_order_acq_rel:
_INVALID_MEMORY_ORDER;
// [[fallthrough]];
case memory_order_seq_cst: store(_Value); return;
}
}
//************
_TVal load() const noexcept // load with sequential consistency 函数重载，返回值是值传递
{
const auto _Mem = _Atomic_address_as<char>(_Storage); // 获得本类中数据成员的地址
char _As_bytes = __iso_volatile_load8(_Mem);
_Compiler_or_memory_barrier(); //= _Compiler_barrier() 插入内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
_TVal load(const memory_order _Order) const noexcept // load with given memory order
{
const auto _Mem = _Atomic_address_as<char>(_Storage);
char _As_bytes = __iso_volatile_load8(_Mem);
_Load_barrier(_Order); // 检查并根据形参内存序的级别，设置内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
//*************
// exchange with given memory order 按指定内存序，把形参 1 的值存入本类中
_TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst)
{
char _As_bytes;
_ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange8, // 由宏函数完成实际的内存交换
_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Value));
return reinterpret_cast<_TVal&>(_As_bytes); // 经测试，是把本类保存的旧值返回
}
/* 此宏函数的定义在本头文件的最上面
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // CAS with given memory order
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
char _Expected_bytes = _Atomic_reinterpret_as<char>(_Expected); // 形参 1 是左值引用
char _Prev_bytes; // 下面宏函数里 函_InterlockedCompareExchange8() 的返回值
// 经测试，函 _InterlockedCompareExchange8() 总返回其形参1 的原值。这里则是本类中的数据成员原始值
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange8, // 包含的函数变了
_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Desired), _Expected_bytes);
if (_Prev_bytes == _Expected_bytes) return true;
reinterpret_cast<char&>(_Expected) = _Prev_bytes; // 形参1 是左值引用
return false;
}
};
//************以下是一个特化模板************
template <class _Ty> // lock-free using 2-byte intrinsics
struct _Atomic_storage<_Ty, 2> // 无锁，使用2字节内置函数
{
typename _Atomic_storage_types<_Ty>::_TStorage _Storage; // 本类的数据成员
using _TVal = remove_reference_t<_Ty>;
_Atomic_storage() = default; // 默认构造函数
_Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) // 有参构造函数
: _Storage{_Value} { }
// template <class _Ty, class _Value_type> 本函数会让本线程睡眠等待，直到形参 1 和 2 不等才返回
// void _Atomic_wait_direct 更准确的描述是等待原子量(形参1 ) 发生变化后才返回
// ( _Atomic_storage<_Ty>* this, _Value_type expected_bytes, memory_order order)
// 所以，本成员函数的语义是等待本类的数据成员与形参 1 不等才返回。
void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Atomic_wait_direct(this, _Atomic_reinterpret_as<short>(_Expected), _Order);
}
void notify_one() { __std_atomic_notify_one_direct(_STD addressof(_Storage)); }
void notify_all() { __std_atomic_notify_all_direct(_STD addressof(_Storage)); }
//********************
void store(const _TVal _Value) noexcept // store with sequential consistency 函数重载
{
const auto _Mem = _Atomic_address_as<short>(_Storage);
const short _As_bytes = _Atomic_reinterpret_as<short>(_Value);
(void) _InterlockedExchange16(_Mem, _As_bytes);
}
void store(const _TVal _Value, const memory_order _Order) noexcept // store with given memory order
{
const auto _Mem = _Atomic_address_as<short>(_Storage);
const short _As_bytes = _Atomic_reinterpret_as<short>(_Value);
switch (_Order)
{
case memory_order_relaxed: __iso_volatile_store16(_Mem, _As_bytes); return;
case memory_order_release:
_Compiler_or_memory_barrier();
__iso_volatile_store16(_Mem, _As_bytes);
return;
default:
case memory_order_consume:
case memory_order_acquire:
case memory_order_acq_rel: _INVALID_MEMORY_ORDER;
// [[fallthrough]];
case memory_order_seq_cst: store(_Value); return;
}
}
//*********************
_TVal load() const noexcept // load with sequential consistency 函数重载
{
const auto _Mem = _Atomic_address_as<short>(_Storage);
short _As_bytes = __iso_volatile_load16(_Mem);
_Compiler_or_memory_barrier(); //= _Compiler_barrier() 插入内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
_TVal load(const memory_order _Order) const noexcept // load with given memory order
{
const auto _Mem = _Atomic_address_as<short>(_Storage);
short _As_bytes = __iso_volatile_load16(_Mem);
_Load_barrier(_Order);
return reinterpret_cast<_TVal&>(_As_bytes);
}
//********************
// exchange with given memory order 按指定内存序，把形参 1 的值存入本类中
_TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept
{
short _As_bytes;
_ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange16,
_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Value));
return reinterpret_cast<_TVal&>(_As_bytes); // 经测试，是把本类保存的旧值返回
}
/*此宏函数的定义在本头文件的最上面
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // CAS with given memory order
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
short _Expected_bytes = _Atomic_reinterpret_as<short>(_Expected); // read before atomic operation
short _Prev_bytes; // 下面宏函数里 函 _InterlockedCompareExchange8() 的返回值
// 经测试，函 _InterlockedCompareExchange16() 总返回其形参1 的原值。这里则是本类中的数据成员原始值
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange16,
_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Desired), _Expected_bytes);
if (_Prev_bytes == _Expected_bytes) return true;
_CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_Ty));
return false;
}
};
//************以下是一个特化模板************
template <class _Ty> // lock-free using 4-byte intrinsics
struct _Atomic_storage<_Ty, 4> // 无锁，使用4字节内置函数
{
typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
using _TVal = remove_reference_t<_Ty>;
_Atomic_storage() = default; // 默认构造函数
// non-atomically initialize this atomic
_Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) // 有参构造函数
: _Storage{_Value} { }
// template <class _Ty, class _Value_type> 本函数会让本线程睡眠等待，直到形参 1 和 2 不等才返回
// void _Atomic_wait_direct 更准确的描述是等待原子量(形参1 ) 发生变化后才返回
// ( _Atomic_storage<_Ty>* this, _Value_type expected_bytes, memory_order order)
// 所以，本成员函数的语义是等待本类的数据成员与形参 1 不等才返回
void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Atomic_wait_direct(this, _Atomic_reinterpret_as<long>(_Expected), _Order);
}
void notify_one() { __std_atomic_notify_one_direct(_STD addressof(_Storage)); }
void notify_all() { __std_atomic_notify_all_direct(_STD addressof(_Storage)); }
//***************
void store(const _TVal _Value) noexcept // store with sequential consistency 函数重载
{
(void) _InterlockedExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Value));
}
void store(const _TVal _Value, const memory_order _Order) noexcept // store with given memory order
{
const auto _Mem = _Atomic_address_as<int>(_Storage) ;
const int _As_bytes = _Atomic_reinterpret_as<int>(_Value);
switch (_Order)
{
case memory_order_relaxed: __iso_volatile_store32(_Mem, _As_bytes); return;
case memory_order_release:
_Compiler_or_memory_barrier(); //= _Compiler_barrier() 插入内存栅栏
__iso_volatile_store32(_Mem, _As_bytes);
return;
default:
case memory_order_consume:
case memory_order_acquire:
case memory_order_acq_rel: _INVALID_MEMORY_ORDER;
// [[fallthrough]];
case memory_order_seq_cst: store(_Value); return;
}
}
//****************************
_TVal load() const noexcept // load with sequential consistency 函数重载
{
const auto _Mem = _Atomic_address_as<int>(_Storage);
auto _As_bytes = __iso_volatile_load32(_Mem);
_Compiler_or_memory_barrier(); //= _Compiler_barrier() 插入内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
_TVal load(const memory_order _Order) const noexcept // load with given memory order
{
const auto _Mem = _Atomic_address_as<int>(_Storage);
auto _As_bytes = __iso_volatile_load32(_Mem);
_Load_barrier(_Order); // 检查并根据形参内存序的级别，设置内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
//********************
// exchange with given memory order 按指定内存序，把形参 1 的值存入本类中
_TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst)
{
long _As_bytes;
_ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange,
_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Value));
return reinterpret_cast<_TVal&>(_As_bytes);
}
/*此宏函数的定义在本头文件的最上面
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // CAS with given memory order
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
long _Expected_bytes = _Atomic_reinterpret_as<long>(_Expected); // read before atomic operation
long _Prev_bytes;
// 经测试，函 _InterlockedCompareExchange8() 总返回其形参1 的原值。这里则是本类中的数据成员原始值
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange,
_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Desired), _Expected_bytes);
if (_Prev_bytes == _Expected_bytes) return true;
_CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
return false;
}
};
//************以下是一个特化模板************
template <class _Ty> // lock-free using 8-byte intrinsics
struct _Atomic_storage<_Ty, 8> // 无锁，使用 8 字节内置函数
{
typename _Atomic_storage_types<_Ty>::_TStorage _Storage; // 本模板类的数据成员
using _TVal = remove_reference_t<_Ty>;
_Atomic_storage() = default; // 默认构造函数
// non-atomically initialize this atomic
_Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) // 有参构造函数
: _Storage{_Value} { }
// template <class _Ty, class _Value_type> 本函数会让本线程睡眠等待，直到形参 1 和 2 不等才返回
// void _Atomic_wait_direct 更准确的描述是等待原子量(形参1 ) 发生变化后才返回
// ( _Atomic_storage<_Ty>* this, _Value_type expected_bytes, memory_order order)
// 所以，本成员函数的语义是等待本类的数据成员与形参 1 不等才返回
void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Atomic_wait_direct(this, _Atomic_reinterpret_as<long long>(_Expected), _Order);
}
void notify_one() { __std_atomic_notify_one_direct(_STD addressof(_Storage)); }
void notify_all() { __std_atomic_notify_all_direct(_STD addressof(_Storage)); }
//***************
void store(const _TVal _Value) noexcept // store with sequential consistency 函数重载
{
const auto _Mem = _Atomic_address_as<long long>(_Storage) ;
const long long _As_bytes = _Atomic_reinterpret_as<long long>(_Value);
(void) _InterlockedExchange64(_Mem, _As_bytes);
}
void store(const _TVal _Value, const memory_order _Order) noexcept // store with given memory order
{
const auto _Mem = _Atomic_address_as<long long>(_Storage);
const long long _As_bytes = _Atomic_reinterpret_as<long long>(_Value);
switch (_Order)
{
case memory_order_relaxed: __iso_volatile_store64(_Mem, _As_bytes); return;
case memory_order_release:
_Compiler_or_memory_barrier(); //= _Compiler_barrier() 插入内存栅栏
__iso_volatile_store64(_Mem, _As_bytes);
return;
default:
case memory_order_consume:
case memory_order_acquire:
case memory_order_acq_rel: _INVALID_MEMORY_ORDER;
// [[fallthrough]];
case memory_order_seq_cst: store(_Value); return;
}
}
//***********************
_TVal load() const noexcept // load with sequential consistency 函数重载
{
const auto _Mem = _Atomic_address_as<long long>(_Storage);
long long _As_bytes;
_As_bytes = __iso_volatile_load64(_Mem);
_Compiler_or_memory_barrier(); //= _Compiler_barrier() 插入内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
_TVal load(const memory_order _Order) const noexcept // load with given memory order
{
const auto _Mem = _Atomic_address_as<long long>(_Storage);
long long _As_bytes = __iso_volatile_load64(_Mem);
_Load_barrier(_Order); // 检查并根据形参内存序的级别，设置内存栅栏
return reinterpret_cast<_TVal&>(_As_bytes);
}
//***********************
// exchange with given memory order 按指定内存序，把形参 1 的值存入本类中
_TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst)
{
long long _As_bytes;
_ATOMIC_CHOOSE_INTRINSIC(_Order, _As_bytes, _InterlockedExchange64,
_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Value));
return reinterpret_cast<_TVal&>(_As_bytes);
}
/*此宏函数的定义在本头文件的最上面
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // CAS with given memory order
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
long long _Expected_bytes = _Atomic_reinterpret_as<long long>(_Expected); // read before atomic operation
long long _Prev_bytes;
// 经测试，函 _InterlockedCompareExchange8() 总返回其形参1 的原值。这里则是本类中的数据成员原始值
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Prev_bytes, _InterlockedCompareExchange64,
_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Desired), _Expected_bytes);
if (_Prev_bytes == _Expected_bytes) return true;
_CSTD memcpy(_STD addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
return false;
}
};
//************以下是一个特化模板************
#ifdef _WIN64 // 本特化版本值存在于 win64 平台上。
template <class _Ty> // lock-free using 16-byte intrinsics
struct _Atomic_storage<_Ty&, 16> // 无锁，使用 16 字节内置函数
{
struct _Int128 { alignas(16) long long _Low; long long _High; }; // 类内定义的类
typename _Atomic_storage_types<_Ty&>::_TStorage _Storage; // 本类的数据成员将是左值引用
/*
template <class _Ty> // 这个特化版本的数据成员的定义，也不同于其泛化版本
struct _Atomic_padded { alignas(sizeof(_Ty)) mutable _Ty _Value; };
template <class _Ty>
struct _Atomic_storage_types { using _TStorage = _Atomic_padded<_Ty>; };
template <class _Ty>
struct _Atomic_storage_types<_Ty&> { using _TStorage = _Ty&; };
*/
using _TVal = remove_reference_t<_Ty&>; // 对于左值引用，_TVal 仍然是基础无引用类型
_Atomic_storage() = default; // 默认构造函数
// non-atomically initialize this atomic
_Atomic_storage(conditional_t<is_reference_v<_Ty&>, _Ty&, const _TVal> _Value) // 有参构造函数
: _Storage{_Value} {}
// 本函数的语义不变：仍然是本类中的数据成员的值不等于形参1 才返回
void wait(_TVal _Expected, memory_order _Order = memory_order_seq_cst) const noexcept
{
const auto _Storage_ptr = _STD addressof(_Storage) ;
const auto _Expected_ptr = _STD addressof(_Expected);
_Int128 _Expected_bytes = reinterpret_cast<const _Int128&>(_Expected);
for (;;)
{
const _TVal _Observed = load(_Order);
_Int128 _Observed_bytes = reinterpret_cast<const _Int128&>(_Observed);
if (_Observed_bytes._Low != _Expected_bytes._Low || _Observed_bytes._High != _Expected_bytes._High)
return;
__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), nullptr,
&_Atomic_wait_compare_16_bytes, _Atomic_wait_no_timeout);
}
}
void notify_one() { __std_atomic_notify_one_indirect(_STD addressof(_Storage)); }
void notify_all() { __std_atomic_notify_all_indirect(_STD addressof(_Storage)); }
//**********************
// 本函数的语义不同于 8 字节以下版本的语义。 本函没有比较的功能，只做交换。
// 本函中形参1 与 2 的值是相同的。
// 本函的功能就是把形参 1 的值设置为本类的数据成员,并把本类中原来的值由形参 1 带回。
// 本函对 16 字节交换成功返回 true ， 失败返回 false 。
bool compare_exchange_strong // CAS with given memory order 本函数被下面的成员函数调用
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
_Int128 _Desired_bytes{}; // 从上下文看，此函数的形参1 与 2 是相等的。
_CSTD memcpy(&_Desired_bytes, _STD addressof(_Desired), sizeof(_TVal));
_Int128 _Expected_temp{};
_CSTD memcpy(&_Expected_temp, _STD addressof(_Expected), sizeof(_TVal));
unsigned char _Result; (void)_Order;
//宏函数 _STD_COMPARE_EXCHANGE_128 = __std_atomic_compare_exchange_128，在本文件上面
//结合上下猜测，函 __std_atomic_compare_exchange_128(..) 的返回值表 16 字节的原子交换操作是否成功;
//交换成功返回 true = 1 ， 失败未交换返回 false = 0
//该函数是把其形参1 中的值与形参4 中的值进行原子交换。形参 2与 3 表示形参4 中的值。
_Result = _STD_COMPARE_EXCHANGE_128 ( &reinterpret_cast<long long&>(_Storage),
_Desired_bytes._High, _Desired_bytes._Low, &_Expected_temp._Low);
if (_Result == 0) // 因为 16 字节的原子交换失败，恢复形参 1 里的值
_CSTD memcpy(_STD addressof(_Expected), &_Expected_temp, sizeof(_TVal));
return _Result != 0;
}
_TVal exchange(const _TVal _Value) noexcept // exchange with sequential consistency 函数重载
{
_TVal _Result{ _Value };
while ( !compare_exchange_strong(_Result, _Value) ) {}// keep trying
return _Result;
}
_TVal exchange(const _TVal _Value, const memory_order _Order) noexcept // exchange with given memory order
{
_TVal _Result{ _Value };
while (!compare_exchange_strong(_Result, _Value, _Order)) {} // keep trying
return _Result;
}
//***********************
// store with sequential consistency
void store(const _TVal _Value) noexcept { (void) exchange(_Value); } // 函数重载
void store(const _TVal _Value, const memory_order _Order) noexcept // store with given memory order
{
_Check_store_memory_order(_Order);
(void) exchange(_Value, _Order);
}
//*********************
_TVal load() const noexcept // load with sequential consistency
{
long long* const _Storage_ptr = // 把 16 字节结构体的地址作为 long long 类型的地址
const_cast<long long*>(_Atomic_address_as<const long long>(_Storage));
_Int128 _Result{}; // atomic CAS 0 with 0
//此函数交换形参 1 与 4 中的值， 形参2与3表示形参 4 中的值。交换成功返回 true。
(void) _STD_COMPARE_EXCHANGE_128(_Storage_ptr, 0, 0, &_Result._Low);
return reinterpret_cast<_TVal&>(_Result);
}
/*
template <class _Integral, class _Ty> // 本函返回形参引用的原始数据的地址
volatile _Integral* _Atomic_address_as(_Ty& _Source) // 本函数是精简版
{ return &reinterpret_cast<volatile _Integral&>(_Source); }
*/
_TVal load(const memory_order _Order) const noexcept // load with given memory order
{
_Check_load_memory_order(_Order);
return load();
}
};
#endif // _WIN64
//*************************以下介绍子类 _Atomic_integral<T,size_t> 及其特化版本******************************
template <class _Ty, size_t = sizeof(_Ty)> // 泛化模板类没有给出定义
struct _Atomic_integral; // not defined
// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty> // atomic integral operations using 1-byte intrinsics
struct _Atomic_integral<_Ty, 1> : _Atomic_storage<_Ty> // 使用内部函数对 1 字节的整数进行原子操作
{
using _Base = _Atomic_storage<_Ty>; // 由于继承，本类仍将具有 1 字节的数据空间，存储了要保护的数据
using typename _Base::_TVal; // 类的声明，使在本域内可见
using _Base::_Base; // 没有找到这个定义。但编译器也不报错。但自己模仿这种写法则会报错。
_TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
char _Result;
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd8,
_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
// SHORT _InterlockedExchangeAdd8( volatile BYTE* Target, BYTE Value );
// 该函数原子地增加形参 1 的值，但返回值是形参1 的旧值
return static_cast<_TVal>(_Result);
}
_TVal operator ++ (int) noexcept // a++
{
return static_cast<_TVal>(_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), 1));
}
_TVal operator ++ () noexcept // ++a
{
unsigned char _Before = static_cast<unsigned char> (
_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), 1) );
++_Before;
return static_cast<_TVal>(_Before);
}
_TVal operator--(int) noexcept // a--
{
return static_cast<_TVal>(_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), -1));
}
_TVal operator--() noexcept // --a
{
unsigned char _Before = static_cast<unsigned char>(
_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), -1) );
--_Before;
return static_cast<_TVal>(_Before);
}
_TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
char _Result;
// BYTE _InterlockedAnd8( volatile BYTE* Target, BYTE Value );
// 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedAnd8,
_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
char _Result;
// BYTE _InterlockedOr8( volatile BYTE* Target, BYTE Value );
// 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedOr8,
_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
char _Result;
// BYTE _InterlockedXor8( volatile BYTE* Destination, BYTE Value );
// 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedXor8,
_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
return static_cast<_TVal>(_Result);
}
};
//***********以下是子类的一个特化模板***********
// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty> // atomic integral operations using 2-byte intrinsics
struct _Atomic_integral<_Ty, 2> : _Atomic_storage<_Ty> // 使用内部函数对 2 字节的整数进行原子操作
{
using _Base = _Atomic_storage<_Ty>;
using typename _Base::_TVal;
using _Base::_Base;
_TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
short _Result;
// 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd16,
_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
return static_cast<_TVal>(_Result);
}
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
_TVal operator ++ (int) noexcept // a++ 这里应该已经有对应的汇编指令了 inc
{
unsigned short _After = static_cast<unsigned short>( // 此函数返回变量增加后的值
_InterlockedIncrement16(_Atomic_address_as<short>(this->_Storage)) );
--_After;
return static_cast<_TVal>(_After);
}
_TVal operator++() noexcept // ++a
{
return static_cast<_TVal>(_InterlockedIncrement16(_Atomic_address_as<short>(this->_Storage)));
}
_TVal operator--(int) noexcept // a--
{
unsigned short _After = static_cast<unsigned short>( // 此函数返回变量递减后的值
_InterlockedDecrement16(_Atomic_address_as<short>(this->_Storage)) );
++_After;
return static_cast<_TVal>(_After);
}
_TVal operator--() noexcept // --a
{
return static_cast<_TVal>(_InterlockedDecrement16(_Atomic_address_as<short>(this->_Storage)));
}
_TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
short _Result;
// 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd16,
_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
short _Result;
// 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedOr16,
_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
short _Result;
// 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor16,
_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
return static_cast<_TVal>(_Result);
}
};
//***********以下是子类的一个特化模板***********
// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty> // atomic integral operations using 4-byte intrinsics
struct _Atomic_integral<_Ty, 4> : _Atomic_storage<_Ty> // 使用内部函数对 4 字节的整数进行原子操作
{
using _Base = _Atomic_storage<_Ty>;
using typename _Base::_TVal;
using _Base::_Base;
// 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
_TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long _Result;
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd,
_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
return static_cast<_TVal>(_Result);
}
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
_TVal operator ++ (int) noexcept // atomic ++
{
unsigned long _After = static_cast<unsigned long>( // 此函数返回变量增加后的值
_InterlockedIncrement(_Atomic_address_as<long>(this->_Storage)) );
--_After;
return static_cast<_TVal>(_After);
}
_TVal operator ++ () noexcept // ++ atomic
{
return static_cast<_TVal>(_InterlockedIncrement(_Atomic_address_as<long>(this->_Storage)));
}
_TVal operator--(int) noexcept // atomic --
{
unsigned long _After = static_cast<unsigned long>( // 此函数返回变量递减后的值
_InterlockedDecrement(_Atomic_address_as<long>(this->_Storage)));
++_After;
return static_cast<_TVal>(_After);
}
_TVal operator--() noexcept // -- atomic
{
return static_cast<_TVal>(_InterlockedDecrement(_Atomic_address_as<long>(this->_Storage)));
}
_TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long _Result;
// 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedAnd,
_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long _Result;
// 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedOr,
_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long _Result;
// 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedXor,
_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
return static_cast<_TVal>(_Result);
}
};
//***********以下是子类的一个特化模板***********
// 整数都原子性的支持：加法、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算。
template <class _Ty> // atomic integral operations using 8-byte intrinsics
struct _Atomic_integral<_Ty, 8> : _Atomic_storage<_Ty> // 使用内部函数对 8 字节的整数进行原子操作
{
using _Base = _Atomic_storage<_Ty>;
using typename _Base::_TVal;
using _Base::_Base;
// 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
_TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long long _Result;
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedExchangeAdd64,
_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
return static_cast<_TVal>(_Result);
}
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
_TVal operator ++ (int) noexcept // a++
{
unsigned long long _After = static_cast<unsigned long long>( // 此函数返回变量增加后的值
_InterlockedIncrement64(_Atomic_address_as<long long>(this->_Storage)));
--_After;
return static_cast<_TVal>(_After);
}
_TVal operator ++ () noexcept // ++a
{
return static_cast<_TVal>(_InterlockedIncrement64(_Atomic_address_as<long long>(this->_Storage)));
}
_TVal operator -- (int) noexcept // a--
{
unsigned long long _After = static_cast<unsigned long long>( // 此函数返回变量递减后的值
_InterlockedDecrement64(_Atomic_address_as<long long>(this->_Storage)));
++_After;
return static_cast<_TVal>(_After);
}
_TVal operator -- () noexcept // --a
{
return static_cast<_TVal>(_InterlockedDecrement64(_Atomic_address_as<long long>(this->_Storage)));
}
_TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long long _Result;
// 该函数原子性的对形参1 进行按位与操作，返回的是形参1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedAnd64,
_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long long _Result;
// 该函数原子性的完成对形参1 的或操作，但返回形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedOr64,
_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
return static_cast<_TVal>(_Result);
}
_TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
long long _Result;
// 此函数原子性的完成对形参1 的异或操作，返回的是形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _InterlockedXor64,
_Atomic_address_as<long long>(this->_Storage), static_cast<long long>(_Operand));
return static_cast<_TVal>(_Result);
}
};
//*********************************************************************************************************
//********爷 _Atomic_storage<T,size_t>、爹 _Atomic_integral<T,size_t>、孙 _Atomic_integral_facade<T>********
//*********************************************************************************************************
template <size_t _TypeSize> // 能同时满足这些条件的只有上面的 1 2 4 8 这四个数。此时不用内部自旋锁了。
bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
template <class _Ty, bool _Is_lock_free = _Is_always_lock_free<sizeof(_Ty)>>
bool _Deprecate_non_lock_free_volatile = true; // 此模板变量恒为 true
template <class _Ty>
bool _Deprecate_non_lock_free_volatile<_Ty, false> = true;
//********************************
/*
template <size_t>
struct _Make_unsigned2; // Choose make_unsigned strategy by type size
template <>
struct _Make_unsigned2<1> {
template <class>
using _Apply = unsigned char;
};
template <>
struct _Make_unsigned2<2> {
template <class>
using _Apply = unsigned short;
};
//template <bool>
//struct _Select { template <class _Ty1, class> using _Apply = _Ty1; };
//template <>
//struct _Select<false> { template <class, class _Ty2> using _Apply = _Ty2; };
template <>
struct _Make_unsigned2<4> {
template <class _Ty> // 大部分情况下 int 等同于 long。所以 此处 _Apply = unsigned long
using _Apply = typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>> ::
template _Apply<unsigned long, unsigned int>;
};
template <>
struct _Make_unsigned2<8> {
template <class>
using _Apply = unsigned long long;
};
template <class _Ty> // unsigned partner to cv-unqualified _Ty
using _Make_unsigned1 = typename _Make_unsigned2<sizeof(_Ty)>::template _Apply<_Ty>;
*/
/*
template <class _Ty>
struct remove_cv // remove top-level const and volatile qualifiers
{
template <template <class> class _Fn> // 模板参数还是模板
using _Apply = _Fn<_Ty>; // apply cv-qualifiers from the class template argument to _Fn<_Ty>
};
template <class _Ty>
struct remove_cv<const _Ty>
{
template <template <class> class _Fn>
using _Apply = const _Fn<_Ty>;
};
template <class _Ty>
struct remove_cv<volatile _Ty>
{
template <template <class> class _Fn>
using _Apply = volatile _Fn<_Ty>;
};
template <class _Ty>
struct remove_cv<const volatile _Ty>
{
template <template <class> class _Fn>
using _Apply = const volatile _Fn<_Ty>;
};
*/
/*
template <class _Ty> // 要求 _Ty 是整数类型且不是 bool 类型
bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;
template <class _Ty>
struct make_unsigned // unsigned partner to _Ty
{
static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
"make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
"integral type or enumeration but not a bool type.");
using type = typename remove_cv<_Ty>::template _Apply<_Make_unsigned1>;
// type ≈ const volatile _Make_unsigned1<_Ty>，即 保留 _Ty 的 cv 修饰符给 模板 _Make_unsigned1<T>
// 最终 type = [ const / volatile ] unsigned [ char, short, long, long long ]
};
template <class _Ty>
using make_unsigned_t = typename make_unsigned<_Ty>::type;
*/
// 至此,整数原子性的支持：加减法、*(-1)取反、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算;
// 以及复合运算符 : +=、-=、&=、|=、^= 。
template <class _Ty> // provides operator overloads and other support for atomic integral specializations
struct _Atomic_integral_facade : _Atomic_integral<_Ty> // 为整数提供了原子操作，facade 外表，表面，外观
{
using _Base = _Atomic_integral<_Ty>; // 本孙子模板类再次扩充了其爷、其爹模板类的成员函数，
using difference_type = _Ty; // 以更好的支持整型数据的加减运算与逻辑运算。
using _Base::_Base;
using _Base::fetch_add;
_Ty fetch_add(const _Ty _Operand) volatile noexcept // 返回值是原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
}
_Ty fetch_add(const _Ty _Operand, const memory_order _Order) volatile noexcept // 指定内存序
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
}
//******定义取反运算*******
static _Ty _Negate(const _Ty _Value) noexcept // 本函数是静态函数，经测试：返回值是形参值乘以 -1
{ // 对 make_unsigned_t<_Ty> 的注释见上面
return static_cast<_Ty>(0U - static_cast<make_unsigned_t<_Ty>>(_Value));
}
//*****定义减法运算********
_Ty fetch_sub(const _Ty _Operand) noexcept { return fetch_add( _Negate(_Operand) ); } // a - b = a + ( -b )
_Ty fetch_sub(const _Ty _Operand) volatile noexcept { return fetch_add( _Negate(_Operand) ); }
_Ty fetch_sub(const _Ty _Operand, const memory_order _Order) noexcept // 函数重载
{
return fetch_add(_Negate(_Operand), _Order); // 依然是返回原子量中的旧值
}
_Ty fetch_sub(const _Ty _Operand, const memory_order _Order) volatile noexcept
{
return fetch_add(_Negate(_Operand), _Order);
}
//*****定义自增运算符******
using _Base::operator++; // 说明对 atomic 的 ++a 与 a++ 都是原子性的
_Ty operator ++ (int) volatile noexcept // a++ 输出原子量中的原值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
}
_Ty operator ++ () volatile noexcept // ++a 输出原子量中的新值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
}
//*****定义自减运算符*****
using _Base::operator--;
_Ty operator -- (int) volatile noexcept // a-- 输出原子量中的原值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
}
_Ty operator -- () volatile noexcept // --a 输出原子量中的新值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
}
//****扩充复合加减运算符****
_Ty operator+=(const _Ty _Operand) noexcept // 旧值 + 增量后的结果作为返回值
{
return static_cast<_Ty>( this->_Base::fetch_add(_Operand) + _Operand );
}
_Ty operator+=(const _Ty _Operand) volatile noexcept // fetch_add(..) 返回的是原子量中的旧值
{
return static_cast<_Ty>( // 先给 this 去掉了 volatile 修饰符
const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand) + _Operand );
}
_Ty operator-=(const _Ty _Operand) noexcept // 旧值 - 形参后的结果作为返回值
{
return static_cast<_Ty>( fetch_sub(_Operand) - _Operand );
}
_Ty operator-=(const _Ty _Operand) volatile noexcept
{
return static_cast<_Ty>( // // fetch_sub(..) 返回的是原子量中的旧值
const_cast<_Atomic_integral_facade*>(this)->fetch_sub(_Operand) - _Operand);
}
//*****与或异或逻辑运算符*****
using _Base::fetch_and;
_Ty fetch_and(const _Ty _Operand) volatile noexcept // 与，返回原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
}
_Ty fetch_and(const _Ty _Operand, const memory_order _Order) volatile noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
}
using _Base::fetch_or;
_Ty fetch_or(const _Ty _Operand) volatile noexcept // 或，返回原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
}
_Ty fetch_or(const _Ty _Operand, const memory_order _Order) volatile noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
}
using _Base::fetch_xor;
_Ty fetch_xor(const _Ty _Operand) volatile noexcept // 异或，返回原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
}
_Ty fetch_xor(const _Ty _Operand, const memory_order _Order) volatile noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
}
//****定义复合逻辑运算符****
_Ty operator&=(const _Ty _Operand) noexcept // 返回与运算的最终结果
{
return static_cast<_Ty>( this->_Base::fetch_and(_Operand) & _Operand );
}
_Ty operator&=(const _Ty _Operand) volatile noexcept // 函数重载
{
return static_cast<_Ty>(
const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand) & _Operand);
}
_Ty operator|=(const _Ty _Operand) noexcept // 返回或运算的最终结果
{
return static_cast<_Ty>(this->_Base::fetch_or(_Operand) | _Operand);
}
_Ty operator|=(const _Ty _Operand) volatile noexcept // 函数重载
{
return static_cast<_Ty>(
const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand) | _Operand);
}
_Ty operator^=(const _Ty _Operand) noexcept // 返回 异或 运算的最终结果
{
return static_cast<_Ty>(this->_Base::fetch_xor(_Operand) ^ _Operand);
}
_Ty operator^=(const _Ty _Operand) volatile noexcept // 函数重载
{
return static_cast<_Ty>(
const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand) ^ _Operand);
}
};
//********************以下介绍特化模板类 _Atomic_integral_facade<_Ty&> *****************************
/*类的继承关系如下：
template <class _Ty, size_t >
struct _Atomic_storage { _Ty _Storage{}; }; // 同时包含了数据类型与引用类型的两种情况
template <class _Ty>
struct _Atomic_integral<_Ty, size_t> : _Atomic_storage<_Ty>
template <class _Ty>
struct _Atomic_integral_facade<_Ty&> : _Atomic_integral<_Ty&>
*/
// 至此,整数原子性的支持：加减法、*(-1)取反、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算;
// 以及复合运算符 : +=、-=、&=、|=、^= 。
template <class _Ty>
struct _Atomic_integral_facade<_Ty&> : _Atomic_integral<_Ty&>
{
using _Base = _Atomic_integral<_Ty&>;
using difference_type = _Ty;
using _Base::_Base;
static _Ty _Negate(const _Ty _Value) noexcept // 对形参值乘以 -1 再返回
{
return static_cast<_Ty>(0U - static_cast<make_unsigned_t<_Ty>>(_Value));
}
_Ty fetch_add(const _Ty _Operand) const noexcept // 返回值是原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
}
_Ty fetch_add(const _Ty _Operand, const memory_order _Order) const noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
}
_Ty fetch_sub(const _Ty _Operand) const noexcept // 依然是返回原子量中的旧值
{
return fetch_add(_Negate(_Operand));
}
_Ty fetch_sub(const _Ty _Operand, const memory_order _Order) const noexcept
{
return fetch_add(_Negate(_Operand), _Order);
}
_Ty operator++(int) const noexcept // a++ 输出原子量中的原值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
}
_Ty operator++() const noexcept // ++a 输出原子量中的新值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
}
_Ty operator--(int) const noexcept // a-- 输出原子量中的原值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
}
_Ty operator--() const noexcept // --a 输出原子量中的新值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
}
_Ty operator+=(const _Ty _Operand) const noexcept // 旧值 + 增量后的结果作为返回值
{
return static_cast<_Ty>( fetch_add(_Operand) + _Operand );
}
_Ty operator-=(const _Ty _Operand) const noexcept // 旧值 - 形参后的结果作为返回值
{
return static_cast<_Ty>(fetch_sub(_Operand) - _Operand);
}
_Ty fetch_and(const _Ty _Operand) const noexcept // 与，返回原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
}
_Ty fetch_and(const _Ty _Operand, const memory_order _Order) const noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
}
_Ty fetch_or(const _Ty _Operand) const noexcept // 或，返回原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
}
_Ty fetch_or(const _Ty _Operand, const memory_order _Order) const noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
}
_Ty fetch_xor(const _Ty _Operand) const noexcept // 异或，返回原子量中的旧值
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
}
_Ty fetch_xor(const _Ty _Operand, const memory_order _Order) const noexcept
{
return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
}
_Ty operator&=(const _Ty _Operand) const noexcept // 返回与运算的最终结果
{
return static_cast<_Ty>(fetch_and(_Operand) & _Operand);
}
_Ty operator|=(const _Ty _Operand) const noexcept // 返回或运算的最终结果
{
return static_cast<_Ty>(fetch_or(_Operand) | _Operand);
}
_Ty operator^=(const _Ty _Operand) const noexcept // 返回 异或 运算的最终结果
{
return static_cast<_Ty>(fetch_xor(_Operand) ^ _Operand);
}
};
//******************** _Atomic_storage<_Ty> 的又一浮点子类 _Atomic_floating<_Ty> **********************
#if _HAS_CXX20
// 浮点类型的原子类型的运算：加减法、+=、-=
template <class _Ty> // provides atomic floating-point operations
struct _Atomic_floating : _Atomic_storage<_Ty> // 本模板为浮点类型提供原子操作
{
using _Base = _Atomic_storage<_Ty>; // float 的父类是 _Atomic_storage<float，4>
using difference_type = _Ty; // double 的父类是 _Atomic_storage<float，8>
using _Base::_Base;
_Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
_Ty _Temp{this->load(memory_order_relaxed)};
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
// bool compare_exchange_strong (T& expected,T desired, memory_order order = seq_cst)
while (!this->compare_exchange_strong(_Temp, _Temp + _Operand, _Order)) {} // keep trying
return _Temp; // 可见，依然是返回原子量的旧值
}
_Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) volatile noexcept
{
return const_cast<_Atomic_floating*>(this)->fetch_add(_Operand, _Order);
}
_Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) noexcept
{
_Ty _Temp{this->load(memory_order_relaxed)};
while (!this->compare_exchange_strong(_Temp, _Temp - _Operand, _Order)) {} // keep trying
return _Temp; // 可见，依然是返回原子量的旧值
}
_Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) volatile noexcept
{
return const_cast<_Atomic_floating*>(this)->fetch_sub(_Operand, _Order);
}
_Ty operator+=(const _Ty _Operand) noexcept // 返回加法的结果
{
return fetch_add(_Operand) + _Operand;
}
_Ty operator+=(const _Ty _Operand) volatile noexcept // 返回加法的结果
{
return const_cast<_Atomic_floating*>(this)->fetch_add(_Operand) + _Operand;
}
_Ty operator-=(const _Ty _Operand) noexcept // 返回减法的结果
{
return fetch_sub(_Operand) - _Operand;
}
_Ty operator-=(const _Ty _Operand) volatile noexcept // 返回减法的结果
{
return const_cast<_Atomic_floating*>(this)->fetch_sub(_Operand) - _Operand;
}
};
//****浮点子类的特化版本 _Atomic_floating<T&> ****
/* 这些注释说明了数据类性的数据成员是数据，引用类型的数据成员，依然是左值引用
template <class _Ty> // 对齐sizeof (T);x86堆栈在4字节边界上对齐8字节对象
struct _Atomic_padded { alignas(sizeof(_Ty)) mutable _Ty _Value; };
template <class _Ty>
struct _Atomic_storage_types { using _TStorage = _Atomic_padded<_Ty>; };
template <class _Ty>
struct _Atomic_storage_types<_Ty&> { using _TStorage = _Ty&; };
template <class _Ty>
struct _Atomic_storage<_Ty, 4> { typename _Atomic_storage_types<_Ty>::_TStorage _Storage; };
*/
// 浮点类型的原子类型的运算：加减法、+=、-=
template <class _Ty> // provides atomic floating-point operations
struct _Atomic_floating<_Ty&> : _Atomic_storage<_Ty&>
{
using _Base = _Atomic_storage<_Ty&>;
using difference_type = _Ty;
using _Base::_Base;
_Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Ty _Temp { this->load(memory_order_relaxed) } ;
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
// bool compare_exchange_strong (T& expected,T desired, memory_order order = seq_cst)
while (!const_cast<_Atomic_floating*>(this)->_Base::compare_exchange_strong( _Temp,
_Temp + _Operand, _Order)) { } // keep trying
return _Temp; // 可见，依然是返回原子量的旧值
}
_Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Ty _Temp { this->load(memory_order_relaxed) };
while (!const_cast<_Atomic_floating*>(this)->_Base::compare_exchange_strong( _Temp,
_Temp - _Operand, _Order)) { } // keep trying
return _Temp;
}
_Ty operator += (const _Ty _Operand) const noexcept // 返回加法的结果
{
return fetch_add(_Operand) + _Operand;
}
_Ty operator -= (const _Ty _Operand) const noexcept // 返回减法的结果
{
return fetch_sub(_Operand) - _Operand;
}
};
#endif // _HAS_CXX20
//********************接着介绍 _Atomic_storage<_Ty> 的指针子类 _Atomic_pointer<_Ty> **********************
// 指针类原子量支持的运算有：加减法、a++、++a、a--、--a、+=、-= 。
template <class _Ty> // 此时 _Ty 是指针类型如 int *
struct _Atomic_pointer : _Atomic_storage<_Ty> // 指针支持加减自增自减操作，但取消了与或异或操作
{
using _Base = _Atomic_storage<_Ty>;
using difference_type = ptrdiff_t; // long long = ptrdiff_t
using _Base::_Base;
//***指针的加法***
// 不同数据类型的指针，移动的步长是不一样的，与数据类型有关。
_Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order = memory_order_seq_cst) noexcept
{
const ptrdiff_t _Shift_bytes = static_cast<ptrdiff_t>( // 把指针的步数换算成以字节为单位的字节数
static_cast<size_t>(_Diff) * sizeof(remove_pointer_t<_Ty>) );
ptrdiff_t _Result;
// 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedExchangeAdd64,
_Atomic_address_as<long long>(this->_Storage), _Shift_bytes);
return reinterpret_cast<_Ty>(_Result); // 返回的是原指针的值
}
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
_Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order) volatile noexcept
{
return const_cast<_Atomic_pointer*>(this)->fetch_add(_Diff, _Order);
}
_Ty fetch_add(const ptrdiff_t _Diff) volatile noexcept // 函数重载
{
return const_cast<_Atomic_pointer*>(this)->fetch_add(_Diff);
}
//***指针的减法***
_Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) noexcept
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
}
_Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) volatile noexcept
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
}
_Ty fetch_sub(const ptrdiff_t _Diff) volatile noexcept // 返回的是原指针的值
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
}
_Ty fetch_sub(const ptrdiff_t _Diff) noexcept
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
}
//***指针自增***
_Ty operator++(int) volatile noexcept { return fetch_add(1); } // 返回旧值
_Ty operator++(int) noexcept { return fetch_add(1); }
_Ty operator++() volatile noexcept { return fetch_add(1) + 1; } // 返回新的原子量的值
_Ty operator++() noexcept { return fetch_add(1) + 1; }
//***指针自减***
_Ty operator--(int) volatile noexcept { return fetch_add(-1); } // 返回旧值
_Ty operator--(int) noexcept { return fetch_add(-1); }
_Ty operator--() volatile noexcept { return fetch_add(-1) - 1; } // 返回新的原子量的值
_Ty operator--() noexcept { return fetch_add(-1) - 1; }
//***复合加减运算符***
_Ty operator+=(const ptrdiff_t _Diff) volatile noexcept
{
return fetch_add(_Diff) + _Diff; // 返回值是原子量更新后的值
}
_Ty operator+=(const ptrdiff_t _Diff) noexcept
{
return fetch_add(_Diff) + _Diff; // 返回值是原子量更新后的值
}
_Ty operator-=(const ptrdiff_t _Diff) volatile noexcept
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
}
_Ty operator-=(const ptrdiff_t _Diff) noexcept // 返回值是原子量更新后的值
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
}
};
//******接着介绍指针原子类的特化版本 _Atomic_pointer<T&>*******
/* 这些注释说明了数据类性的数据成员是数据，引用类型的数据成员，依然是左值引用
template <class _Ty> // 对齐sizeof (T);x86堆栈在4字节边界上对齐8字节对象
struct _Atomic_padded { alignas(sizeof(_Ty)) mutable _Ty _Value; };
template <class _Ty>
struct _Atomic_storage_types { using _TStorage = _Atomic_padded<_Ty>; };
template <class _Ty>
struct _Atomic_storage_types<_Ty&> { using _TStorage = _Ty&; };
template <class _Ty>
struct _Atomic_storage<_Ty, 8> { typename _Atomic_storage_types<_Ty>::_TStorage _Storage; };
*/
template <class _Ty> // 引用类型的成员函数都没有了 volatile 修饰符
struct _Atomic_pointer<_Ty&> : _Atomic_storage<_Ty&>
{
using _Base = _Atomic_storage<_Ty&>;
using difference_type = ptrdiff_t;
using _Base::_Base;
//***指针的加减法***
_Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order = memory_order_seq_cst) const noexcept
{
const ptrdiff_t _Shift_bytes = static_cast<ptrdiff_t>(
static_cast<size_t>(_Diff) * sizeof(remove_pointer_t<_Ty>) );
ptrdiff_t _Result;
// 该函数原子地增加形参 1 的值，但返回值是形参 1 的旧值。
_ATOMIC_CHOOSE_INTRINSIC( _Order, _Result, _InterlockedExchangeAdd64,
_Atomic_address_as<long long>(this->_Storage), _Shift_bytes);
return reinterpret_cast<_Ty>(_Result); // 返回的是原指针的值
}
/*
#define _ATOMIC_CHOOSE_INTRINSIC(_Order, _Result, _Intrinsic, ...) \
_Check_memory_order(_Order); \
_Result = _Intrinsic(__VA_ARGS__)
*/
_Ty fetch_sub(const ptrdiff_t _Diff) const noexcept // 返回的是原指针的值
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
}
_Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) const noexcept
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
}
//***自增自减运算符***
_Ty operator++(int) const noexcept { return fetch_add(1); } // 返回旧值
_Ty operator++() const noexcept { return fetch_add(1) + 1; } // 返回新的原子量的值
_Ty operator--(int) const noexcept { return fetch_add(-1); } // 返回旧值
_Ty operator--() const noexcept { return fetch_add(-1) - 1; } // 返回新的原子量的值
//***复合加减运算符***
_Ty operator+=(const ptrdiff_t _Diff) const noexcept // 返回值是原子量更新后的值
{
return fetch_add(_Diff) + _Diff;
}
_Ty operator-=(const ptrdiff_t _Diff) const noexcept // 返回值是原子量更新后的值
{
return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
}
};
//*************************************** 接着介绍 atomic<T> 的父类的定义 *********************************
#define ATOMIC_VAR_INIT(_Value) { _Value } // 定义了一个宏函数
/*
_Atomic_integral<T , 8> : _Atomic_storage<T , 8> ; // 特化版本之间，对应完成继承
_Atomic_integral<T , 4> : _Atomic_storage<T , 4> ;
_Atomic_integral<T , 2> : _Atomic_storage<T , 2> ;
_Atomic_integral<T , 1> : _Atomic_storage<T , 1> ;
*/
/*
template <class _Ty> // 对齐sizeof (T);x86堆栈在4字节边界上对齐8字节对象
struct _Atomic_padded
{ alignas(sizeof(_Ty)) mutable _Ty _Value; };
template <class _Ty>
struct _Atomic_storage_types {
using _TStorage = _Atomic_padded<_Ty>;
using _Spinlock = long;
};
template <class _Ty>
struct _Atomic_storage_types<_Ty&> {
using _TStorage = _Ty&;
using _Spinlock = _Smtx_t*; // POINTER TO mutex
};
//-----------------------------------------------------------------------------
template <class _Ty, size_t = sizeof(_Ty)> // 有 1 2 4 8 的重载, 也有其泛化版本的定义
struct _Atomic_storage { };
template <class _Ty, size_t = sizeof(_Ty)> // 有 1 2 4 8 的重载，但其泛化版本无定义
struct _Atomic_integral : _Atomic_storage<_Ty> {};
template <class _Ty> // 本模板作为普通整形 atomic<int> 的父类 ,本类并无数据成员
struct _Atomic_integral_facade : _Atomic_integral<_Ty>{ };
template <class _Ty> // atomic value
struct atomic : _Choose_atomic_base_t<_Ty>{};
*/
/*
template <class _Ty>
bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char,
wchar_t,
#ifdef __cpp_char8_t
char8_t,
#endif // __cpp_char8_t
char16_t, char32_t, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>;
*/
// 对于布尔型的 atomic 要更简单，直接 atomic 继承 _Atomic_storage<_Ty> ！！相应的允许的对布尔型的操作也要少一些，没那么多成员函数。
template <class _TVal, class _Ty = _TVal>
using _Choose_atomic_base2_t = typename _Select< is_integral_v<_TVal> && !is_same_v<bool, _TVal>>::
template _Apply< _Atomic_integral_facade<_Ty>, // 可见对于普通整形， atomic 以 _Atomic_integral_facade<_Ty> 为 父类
typename _Select<is_pointer_v<_TVal> && is_object_v<remove_pointer_t<_TVal>>>:: // 这是要选择布尔型么？
template _Apply< _Atomic_pointer<_Ty>, _Atomic_storage<_Ty>>
>;
/*
template <class>
bool is_pointer_v = false; // determine whether _Ty is a pointer
template <class _Ty>
bool is_pointer_v<_Ty*> = true;
template <class _Ty>
bool is_pointer_v<_Ty* const> = true;
template <class _Ty>
bool is_pointer_v<_Ty* volatile> = true;
template <class _Ty>
bool is_pointer_v<_Ty* const volatile> = true;
//---------------------------------------------------------------------------------------------
template <class _Ty> // only function types and reference types can't be const qualified
bool is_function_v = !is_const_v<const _Ty> && !is_reference_v<_Ty>;
template <class _Ty> // 对于函数和引用类型 is_const_v<const _Ty> = false ，这是编译器的特殊设置
struct is_function : bool_constant<is_function_v<_Ty>> {};
template <class _Ty> // only function types and reference types can't be const qualified
bool is_object_v = is_const_v<const _Ty> && !is_void_v<_Ty>;
*/
/*
template <class _Ty>
struct remove_pointer
{ using type = _Ty; };
template <class _Ty>
struct remove_pointer<_Ty*>
{ using type = _Ty; };
template <class _Ty>
struct remove_pointer<_Ty* const>
{ using type = _Ty; };
template <class _Ty>
struct remove_pointer<_Ty* volatile>
{ using type = _Ty; };
template <class _Ty>
struct remove_pointer<_Ty* const volatile>
{ using type = _Ty; };
template <class _Ty>
using remove_pointer_t = typename remove_pointer<_Ty>::type;
*/
// 对于非整形，非浮点型，非布尔型，但是是对象的指针类型，则 atomic 继承 _Atomic_pointer<_Ty>
/*
template <bool _First_value, class _First, class... _Rest> // handle true trait or last trait
struct _Disjunction {
using type = _First;
};
template <class _False, class _Next, class... _Rest> // first trait is false, try the next trait
struct _Disjunction<false, _False, _Next, _Rest...> {
using type = typename _Disjunction<_Next::value, _Next, _Rest...>::type;
};
template <class... _Traits> // If _Traits is empty, false_type
struct disjunction : false_type {}; // disj 有一个为真就为 真，所有都为假才为假。
template <class _First, class... _Rest> // the first true trait in _Traits, or the last trait if none are true
struct disjunction<_First, _Rest...> : _Disjunction<_First::value, _First, _Rest...>::type { };
template <class... _Traits>
bool disjunction_v = disjunction<_Traits...>::value;
//--------------------------------------------------------------------------------------------------------------
template <class _Ty, class... _Types> // true if and only if _Ty is in _Types
bool _Is_any_of_v = disjunction_v<is_same<_Ty, _Types>...>;
template <class _Ty>
bool is_floating_point_v = _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;
*/
/*
template <bool>
struct _Select { template <class _Ty1, class> using _Apply = _Ty1; };
template <>
struct _Select<false> { template <class, class _Ty2> using _Apply = _Ty2; };
*/
template <class _TVal, class _Ty = _TVal> // 此处是为了区分浮点型与整形，为 atomic 提供不同的父类
using _Choose_atomic_base_t = typename _Select<is_floating_point_v<_TVal>> ::
template _Apply<_Atomic_floating<_Ty>, _Choose_atomic_base2_t<_TVal, _Ty>>;
//*************************************** 介绍最实用的类 atomic<T> *****************************************
/*
（1）整数原子性的支持：加减法、*(-1)取反、a++、++a、a--、--a 以及按位的 与and、或or、异或xor 运算;
以及复合运算符 : +=、-=、&=、|=、^= 。
（2）指针类原子量支持的运算有：加减法、a++、++a、a--、--a、+=、-= 。
（3）浮点类型的原子类型的运算：加减法、+=、-= 。
（4）bool 类型只支持 赋值读值的 store ()、load () 这俩原子操作。
*/
template <class _Ty>
struct atomic : _Choose_atomic_base_t<_Ty>
{
private:
using _Base = _Choose_atomic_base_t<_Ty>;
public: // 要求 类型 _Ty 支持复制构造与移动构造的操作
static_assert( is_trivially_copyable_v<_Ty> && is_copy_constructible_v<_Ty> &&
is_copy_assignable_v<_Ty> && is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>,
"atomic<T> requires T to be trivially copyable, copy constructible, "
"move constructible, copy assignable, and move assignable." );
using value_type = _Ty; using _Base::_Base;
// template <size_t _TypeSize> // 当 T 的大小为 1 2 4 8 字节时将不需要自旋锁来保护数据
// bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
static constexpr bool is_always_lock_free = _Is_always_lock_free<sizeof(_Ty)>; // 类的静态数据成员
atomic() noexcept(is_nothrow_default_constructible_v<_Ty>) : _Base() {} // 默认构造函数
atomic(const atomic&) = delete; // 禁止了 copy 构造函数
atomic& operator=(const atomic&) = delete; // 禁止了 copy 赋值运算符函数
//****测试本模板参数的类型是否是免自旋锁的****
bool is_lock_free() const volatile noexcept // 对于 1 2 4 8 16 将返回 true
{
constexpr bool _Result = sizeof(_Ty) <= 8 && (sizeof(_Ty) & sizeof(_Ty) - 1) == 0;
return _Result;
}
bool is_lock_free() const noexcept // 调用了上面的重载函数，对 this 的修饰不一样
{
return static_cast<const volatile atomic*>(this)->is_lock_free();
}
//****往 atomic<T> 里原子地写入数据****
using _Base::store;
/*
template <size_t _TypeSize> // 能同时满足这些条件的只有上面的 1 2 4 8 这四个数。此时不用内部自旋锁了。
bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
template <class _Ty, bool _Is_lock_free = _Is_always_lock_free<sizeof(_Ty)>>
bool _Deprecate_non_lock_free_volatile = true; // 此模板变量恒为 true
template <class _Ty>
bool _Deprecate_non_lock_free_volatile<_Ty, false> = true;
*/
void store(const _Ty _Value) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails"); // 断言恒为真
const_cast<atomic*>(this)->_Base::store(_Value);
}
void store(const _Ty _Value, const memory_order _Order) volatile noexcept // 函数重载
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
const_cast<atomic*>(this)->_Base::store(_Value, _Order);
}
_Ty operator = (const _Ty _Value) volatile noexcept // 赋值运算符函数
{ // 加 volitile 是不要编译器过度优化，从内存读值
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails"); // 断言恒为真
this->store(_Value); // 调用了上面的函数
return _Value; // 返回 atomic<T> 原子量的新值
}
_Ty operator=(const _Ty _Value) noexcept
{
this->store(_Value);
return _Value;
}
//****从 atomic<T> 里原子地读值****
using _Base::load;
_Ty load() const volatile noexcept // 返回值是值传递或左值引用，取决于 atomic<_Ty> 中模板参数的类型
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return const_cast<const atomic*>(this)->_Base::load();
}
/*
template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)> // 泛化模板类
struct _Atomic_storage
{
_Ty _Storage{}; // 原子量要保护的数据成员，是个引用，也可以是一个值，都包括了
using _TVal = remove_reference_t<_Ty> ; // 该类的特化模板，也都采用了 _TVal 来作为 load() 的返回值
_TVal load(const memory_order _Order = memory_order_seq_cst) const noexcept // 读取值
{
_Check_load_memory_order(_Order); // 允许的读取内存序：relaxed、acquire、seq_cst
_Guard _Lock{ _Spinlock }; // 先获取自旋锁，再读取数据
_TVal _Local(_Storage);
return _Local; // 返回值是值传递
}
};
*/
_Ty load(const memory_order _Order) const volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return const_cast<const atomic*>(this)->_Base::load(_Order);
}
//**** atomic<T> 支持的类型转换运算符函数 ****
operator _Ty () const volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return this->load();
}
operator _Ty () const noexcept { return this->load(); }
//**** atomic<T> 支持等待与唤醒操作 ****
using _Base::wait; // wait（）被 nofify（）唤醒后，如果原子量的值等于形参 1，还是不会返回的。
void wait(const _Ty _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept
{
const_cast<const atomic*>(this)->_Base::wait(_Expected, _Order);
}
/*
template <class _Ty, size_t > // 泛化版本
struct _Atomic_storage
{ // 简单情况下 _Spinlock = long 类型。引用情况下 _Spinlock 是 void * 类型。
mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{}; // 定义了一个自旋锁
using _TVal = remove_reference_t<_Ty>;
_Ty _Storage{}; // 原子量要保护的数据成员，是个引用，也可以是一个值，都包括了
void wait(_TVal _Expected, memory_order = memory_order_seq_cst) const noexcept // 值不等于形参 1 才返回
{
const auto _Storage_ptr = _STD addressof(_Storage);
const auto _Expected_ptr = _STD addressof(_Expected);
for (;;) // 可见，wait（）被 nofify（）唤醒后，如果原子量的值等于形参 1，还是不会返回的。
{
{ _Guard _Lock{ _Spinlock }; // 取得自旋锁
if (_CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) != 0) return;
}
__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), &_Spinlock,
&_Atomic_wait_compare_non_lock_free<decltype(_Spinlock)>, _Atomic_wait_no_timeout);
}
}
};
*/
using _Base::notify_one;
void notify_one() volatile noexcept
{
const_cast<atomic*>(this)->_Base::notify_one();
}
using _Base::notify_all;
void notify_all() volatile noexcept
{
const_cast<atomic*>(this)->_Base::notify_all();
}
//**** 与形参交换数值 ****
using _Base::exchange;
_Ty exchange(const _Ty _Value) volatile noexcept // 存储形参里的新值，返回原子量里的旧值
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return const_cast<atomic*>(this)->_Base::exchange(_Value);
}
/*
template <class _Ty, size_t > // 泛化版本似乎简单
struct _Atomic_storage
{
mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{};
using _TVal = remove_reference_t<_Ty>;
_Ty _Storage{};
// exchange _Value with _Storage with sequential consistency // 意思是 atomic 存入新值，把旧值返回去
_TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept
{
_Check_memory_order(_Order);
_Guard _Lock{ _Spinlock };
_TVal _Result(_Storage);
_Storage = _Value;
return _Result;
}
};
*/
_Ty exchange(const _Ty _Value, const memory_order _Order) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return const_cast<atomic*>(this)->_Base::exchange(_Value, _Order);
}
//**** 比较并强交换 ****
using _Base::compare_exchange_strong;
bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return const_cast<atomic*>(this)->_Base::compare_exchange_strong(_Expected, _Desired);
}
/*
template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)>
struct _Atomic_storage
{
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // 注意：形参1 是左值引用，对左值引用取地址返回的是原始值的地址
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
_Check_memory_order(_Order);
const auto _Storage_ptr = _STD addressof(_Storage); // 取本类中数据成员的地址
const auto _Expected_ptr = _STD addressof(_Expected);
bool _Result;
_Guard _Lock{ _Spinlock }; // 取得自旋锁
_Result = _CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
if (_Result)
_CSTD memcpy(_Storage_ptr, _STD addressof(_Desired), sizeof(_TVal));
else
_CSTD memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
return _Result;
}
};
*/
bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return const_cast<atomic*>(this)->_Base::compare_exchange_strong(_Expected, _Desired, _Order);
}
bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired,
const memory_order _Success, const memory_order _Failure) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return this->compare_exchange_strong( _Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
bool compare_exchange_strong( _Ty& _Expected, const _Ty _Desired,
const memory_order _Success, const memory_order _Failure) noexcept
{
return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
//**** 比较并弱交换 ****
// we have no weak CAS intrinsics, even on ARM32/ARM64, so fall back to strong
// 我们没有弱的 CAS 内置函数，即使在 ARM32/ARM64 上也是如此，所以等价于调用 compare_exchange_strong()
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) noexcept
{
return this->compare_exchange_strong(_Expected, _Desired);
}
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return this->compare_exchange_strong(_Expected, _Desired);
}
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return this->compare_exchange_strong(_Expected, _Desired, _Order);
}
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) noexcept
{
return this->compare_exchange_strong(_Expected, _Desired, _Order);
}
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired,
const memory_order _Success, const memory_order _Failure) volatile noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
bool compare_exchange_weak( _Ty& _Expected, const _Ty _Desired,
const memory_order _Success, const memory_order _Failure) noexcept
{
return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
};
//****************************** 以下介绍对已知量进行保护的重要基础类 atomic_ref<T> *****************************
#if _HAS_CXX17
template <class _Ty>
atomic(_Ty) -> atomic<_Ty>;
#endif // _HAS_CXX17
#if _HAS_CXX20
// template <class _TVal, class _Ty = _TVal> // 此处是为了区分浮点型与其它类型（整数、指针等）
// using _Choose_atomic_base_t = typename _Select<is_floating_point_v<_TVal>> ::
// template _Apply<_Atomic_floating<_Ty>, _Choose_atomic_base2_t<_TVal, _Ty>>;
// 经测试， atomic<T> 中 T 不可以为左值引用或右值引用类型，所以 c++20 里定义了本模板类
// template <class _Ty>
// struct atomic : _Choose_atomic_base_t<_Ty> {} ;
template <class _Ty> // 使用时定义模板参数 _Ty 为基础非引用类型即可。
struct atomic_ref : _Choose_atomic_base_t<_Ty, _Ty&> // atomic reference 本模板类专注于引用的原子存储
{
public: // 以下是类里定义的静态变量
// template <size_t _TypeSize> // 能同时满足这些条件的只有上面的 1 2 4 8 这四个数。此时不用内部自旋锁了。
// bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
static constexpr bool is_always_lock_free = _Is_always_lock_free<sizeof(_Ty)>;
static constexpr bool _Is_potentially_lock_free = // 64 位环境里 16 字节也认为是可免自旋锁的。
sizeof(_Ty) <= 2 * sizeof(void*) && (sizeof(_Ty) & (sizeof(_Ty) - 1)) == 0;
static constexpr size_t required_alignment = _Is_potentially_lock_free ? sizeof(_Ty) : alignof(_Ty);
// 经测试 sizeof(T) >= alignof(T)
private:
// #define _ATOMIC_REF_CHECK_ALIGNMENT(cond, mesg) _STL_VERIFY(cond, mesg) 宏函数
// [[maybe_unused]] 是 c++17 引入的对变量、参数、函数的修饰符，不要提示变量未使用。
// 本函数的语义是要求本原子量引用的基础变量的内存地址是对齐的。否则报错。
static void _Check_alignment ( [[maybe_unused]] const _Ty& _Value ) // 本函被构造函数调用
{
_ATOMIC_REF_CHECK_ALIGNMENT( // 要求形参1 cond 必须为 true
( reinterpret_cast<uintptr_t>( _STD addressof(_Value)) & (required_alignment - 1) ) == 0,
"atomic_ref underlying object is not aligned as required_alignment"
); // uintptr_t = u_long_long
}
using _Base = _Choose_atomic_base_t<_Ty, _Ty&>;
public: // 经测试，模板参数 _Ty 只可以是基础类型。若 _Ty 是左值引用或右值引用则报错。
static_assert(is_trivially_copyable_v<_Ty>, "atomic_ref<T> requires T to be trivially copyable.");
using value_type = _Ty; // 值类型，不包括引用 & && 这俩修饰符
explicit atomic_ref(_Ty& _Value) : _Base(_Value) // 有参构造函数
{
if constexpr (_Is_potentially_lock_free) // 免自旋锁的情况下要求变量的地址是内存对齐的。
_Check_alignment(_Value);
else
this->_Init_spinlock_for_ref(); // 否则就初始化基类中的自旋锁 _Atomic_storage<T>::_Spinlock
}
/*
template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)>
struct _Atomic_storage
{
mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{}; // 定义了一个自旋锁
void _Init_spinlock_for_ref() { _Spinlock = __std_atomic_get_mutex(_STD addressof(_Storage)); }
};
*/
atomic_ref(const atomic_ref&) noexcept = default; // 禁止 copy 构造函数
atomic_ref& operator=(const atomic_ref&) = delete; // 禁止 copy 赋值运算符函数
bool is_lock_free() // 测试模板参数 _Ty 是否是免自旋锁的。
{
if constexpr (is_always_lock_free) // 64 位 intel CPU 是有汇编指令 cmpxchg16b 的。
return true;
else
return __std_atomic_has_cmpxchg16b() != 0; // 有汇编指令 cmpxchg16b 则也是免自旋锁的。
}
//****写入原子量****
void store(const _Ty _Value) const noexcept
{
const_cast<atomic_ref*>(this)->_Base::store(_Value);
}
void store(const _Ty _Value, const memory_order _Order) const noexcept
{
const_cast<atomic_ref*>(this)->_Base::store(_Value, _Order);
}
_Ty operator=(const _Ty _Value) const noexcept
{
store(_Value);
return _Value;
}
//****写入原子量，返回旧值****
_Ty exchange(const _Ty _Value) const noexcept
{
return const_cast<atomic_ref*>(this)->_Base::exchange(_Value);
}
_Ty exchange(const _Ty _Value, const memory_order _Order) const noexcept
{
return const_cast<atomic_ref*>(this)->_Base::exchange(_Value, _Order);
}
//**** 类型转换运算符与唤醒 ****
operator _Ty () const noexcept { return this->load(); }
void notify_one() const noexcept
{
const_cast<atomic_ref*>(this)->_Base::notify_one();
}
void notify_all() const noexcept
{
const_cast<atomic_ref*>(this)->_Base::notify_all();
}
//****比较及强交换****
bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired) const noexcept
{
return const_cast<atomic_ref*>(this)->_Base::compare_exchange_strong(_Expected, _Desired);
}
/*
template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)>
struct _Atomic_storage
{
// 当本类中存储的值 等于形参1 时，把形参 2 的值存入本类；
// 当本类中存储的值 不等于形参1 时，把本类中的值写入形参 1 。有点指令 cmpxchg 的语义。
// 返回值表示形参1 与本类中的值是否相等，是则返回 true。
bool compare_exchange_strong // 注意：形参1 是左值引用，对左值引用取地址返回的是原始值的地址
(_TVal& _Expected, const _TVal _Desired, const memory_order _Order = memory_order_seq_cst)
{
_Check_memory_order(_Order);
const auto _Storage_ptr = _STD addressof(_Storage); // 取本类中数据成员的地址
const auto _Expected_ptr = _STD addressof(_Expected);
bool _Result;
_Guard _Lock{ _Spinlock }; // 取得自旋锁
_Result = _CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
if (_Result)
_CSTD memcpy(_Storage_ptr, _STD addressof(_Desired), sizeof(_TVal));
else
_CSTD memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
return _Result;
}
};
*/
bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) const noexcept
{
return const_cast<atomic_ref*>(this)->_Base::compare_exchange_strong(_Expected, _Desired, _Order);
}
bool compare_exchange_strong( _Ty& _Expected, const _Ty _Desired,
const memory_order _Success, const memory_order _Failure) const noexcept
{
return compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
//****比较及弱交换****
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) const noexcept
{
return compare_exchange_strong(_Expected, _Desired);
}
bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) const noexcept
{
return compare_exchange_strong(_Expected, _Desired, _Order);
}
bool compare_exchange_weak( _Ty& _Expected, const _Ty _Desired, const memory_order _Success,
const memory_order _Failure) const noexcept
{
return compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
};
#endif // _HAS_CXX20
//********************** 丰富了 atomic<bool> 功能的原子标志类 atomic_flag *************************************
#define ATOMIC_FLAG_INIT \
{}
struct atomic_flag // flag with test-and-set semantics 带有测试和设置语义的标志
{
atomic<long> _Storage; // 本类的数据成员，存储 0 表 false， 1 表 true
constexpr atomic_flag() noexcept = default; // 默认的构造函数
#if _HAS_CXX20
bool test(const memory_order _Order = memory_order_seq_cst) const noexcept
{
return _Storage.load(_Order) != 0; // 若本类的数据成员不为 0 则返回 true
}
bool test(const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
return _Storage.load(_Order) != 0;
}
#endif // _HAS_CXX20
bool test_and_set(const memory_order _Order = memory_order_seq_cst) noexcept
{
return _Storage.exchange(true, _Order) != 0; // 设置本类的数据成员为 1 且返回旧值
}
bool test_and_set(const memory_order _Order = memory_order_seq_cst) volatile noexcept
{
return _Storage.exchange(true, _Order) != 0;
}
void clear(const memory_order _Order = memory_order_seq_cst) noexcept
{
_Storage.store(false, _Order); // 设置本类的数据成员为 0
}
void clear(const memory_order _Order = memory_order_seq_cst) volatile noexcept
{
_Storage.store(false, _Order);
}
#if _HAS_CXX20
void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept
{
_Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
}
// wait(..) 是值不等于 形参 1 _Expected 才返回。
void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept
{
_Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
}
/*
template <class _Ty, size_t > // 泛化版本
struct _Atomic_storage
{ // 简单情况下 _Spinlock = long 类型。引用情况下 _Spinlock 是 void * 类型。
mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{}; // 定义了一个自旋锁
using _TVal = remove_reference_t<_Ty>;
_Ty _Storage{}; // 原子量要保护的数据成员，是个引用，也可以是一个值，都包括了
void wait(_TVal _Expected, memory_order = memory_order_seq_cst) const noexcept // 值不等于形参 1 才返回
{
const auto _Storage_ptr = _STD addressof(_Storage);
const auto _Expected_ptr = _STD addressof(_Expected);
for (;;) // 可见，wait（）被 nofify（）唤醒后，如果原子量的值等于形参 1，还是不会返回的。
{
{ _Guard _Lock{ _Spinlock }; // 取得自旋锁
if (_CSTD memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) != 0) return;
}
__std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), &_Spinlock,
&_Atomic_wait_compare_non_lock_free<decltype(_Spinlock)>, _Atomic_wait_no_timeout);
}
}
};
*/
void notify_one() noexcept { _Storage.notify_one(); }
void notify_one() volatile noexcept { _Storage.notify_one(); }
void notify_all() noexcept { _Storage.notify_all(); }
void notify_all() volatile noexcept { _Storage.notify_all(); }
#endif // _HAS_CXX20
};
//*********************** 以下这些全局函数的功能还是由重要类的成员函数实现的，不再注释了 *******************************
//*********************** 在编辑器的智能提示下，还是使用类的成员函数更方便。 *******************************
template <class _Ty>
bool atomic_is_lock_free(const volatile atomic<_Ty>* _Mem) noexcept {
return _Mem->is_lock_free();
}
template <class _Ty>
bool atomic_is_lock_free(const atomic<_Ty>* _Mem) noexcept {
return _Mem->is_lock_free();
}
template <class _Ty>
void atomic_store(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
_Mem->store(_Value);
}
template <class _Ty>
void atomic_store(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept
{
_Mem->store(_Value);
}
template <class _Ty>
void atomic_store_explicit(
volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
_Mem->store(_Value, _Order);
}
template <class _Ty>
void atomic_store_explicit(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept
{
_Mem->store(_Value, _Order);
}
template <class _Ty>
_CXX20_DEPRECATE_ATOMIC_INIT void atomic_init(
volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
_STD atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
}
template <class _Ty>
_CXX20_DEPRECATE_ATOMIC_INIT void atomic_init(
atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept
{
_STD atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
}
template <class _Ty>
_Ty atomic_load(const volatile atomic<_Ty>* const _Mem) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->load();
}
template <class _Ty>
_Ty atomic_load(const atomic<_Ty>* const _Mem) noexcept
{
return _Mem->load();
}
template <class _Ty>
_Ty atomic_load_explicit(const volatile atomic<_Ty>* const _Mem, const memory_order _Order) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->load(_Order);
}
template <class _Ty>
_Ty atomic_load_explicit(const atomic<_Ty>* const _Mem, const memory_order _Order) noexcept
{
return _Mem->load(_Order);
}
template <class _Ty>
_Ty atomic_exchange(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->exchange(_Value);
}
template <class _Ty>
_Ty atomic_exchange(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept
{
return _Mem->exchange(_Value);
}
template <class _Ty>
_Ty atomic_exchange_explicit(
volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->exchange(_Value, _Order);
}
template <class _Ty>
_Ty atomic_exchange_explicit(
atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept
{
return _Mem->exchange(_Value, _Order);
}
template <class _Ty>
bool atomic_compare_exchange_strong(
volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->compare_exchange_strong(*_Expected, _Desired);
}
template <class _Ty>
bool atomic_compare_exchange_strong(
atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept
{
return _Mem->compare_exchange_strong(*_Expected, _Desired);
}
template <class _Ty>
bool atomic_compare_exchange_strong_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
template <class _Ty>
bool atomic_compare_exchange_strong_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept
{
return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
template <class _Ty>
bool atomic_compare_exchange_weak(
volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->compare_exchange_strong(*_Expected, _Desired);
}
template <class _Ty>
bool atomic_compare_exchange_weak(
atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept
{
return _Mem->compare_exchange_strong(*_Expected, _Desired);
}
template <class _Ty>
bool atomic_compare_exchange_weak_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
template <class _Ty>
bool atomic_compare_exchange_weak_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept
{
return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}
template <class _Ty>
_Ty atomic_fetch_add(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept
{
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_add(_Value);
}
template <class _Ty>
_Ty atomic_fetch_add(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
return _Mem->fetch_add(_Value);
}
template <class _Ty>
_Ty atomic_fetch_add_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
const memory_order _Order) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_add(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_add_explicit(
atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
return _Mem->fetch_add(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_sub(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_sub(_Value);
}
template <class _Ty>
_Ty atomic_fetch_sub(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
return _Mem->fetch_sub(_Value);
}
template <class _Ty>
_Ty atomic_fetch_sub_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
const memory_order _Order) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_sub(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_sub_explicit(
atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
return _Mem->fetch_sub(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_and(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_and(_Value);
}
template <class _Ty>
_Ty atomic_fetch_and(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
return _Mem->fetch_and(_Value);
}
template <class _Ty>
_Ty atomic_fetch_and_explicit(
volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_and(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_and_explicit(
atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
return _Mem->fetch_and(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_or(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_or(_Value);
}
template <class _Ty>
_Ty atomic_fetch_or(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
return _Mem->fetch_or(_Value);
}
template <class _Ty>
_Ty atomic_fetch_or_explicit(
volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_or(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_or_explicit(
atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
return _Mem->fetch_or(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_xor(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_xor(_Value);
}
template <class _Ty>
_Ty atomic_fetch_xor(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
return _Mem->fetch_xor(_Value);
}
template <class _Ty>
_Ty atomic_fetch_xor_explicit(
volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
return _Mem->fetch_xor(_Value, _Order);
}
template <class _Ty>
_Ty atomic_fetch_xor_explicit(
atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
return _Mem->fetch_xor(_Value, _Order);
}
#if _HAS_CXX20
template <class _Ty>
void atomic_wait(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept
/* strengthened */ {
_Mem->wait(_Expected);
}
template <class _Ty>
void atomic_wait(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept
/* strengthened */ {
_Mem->wait(_Expected);
}
template <class _Ty>
void atomic_wait_explicit(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
const memory_order _Order) noexcept /* strengthened */ {
_Mem->wait(_Expected, _Order);
}
template <class _Ty>
void atomic_wait_explicit(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
const memory_order _Order) noexcept /* strengthened */ {
_Mem->wait(_Expected, _Order);
}
template <class _Ty>
void atomic_notify_one(volatile atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
_Mem->notify_one();
}
template <class _Ty>
void atomic_notify_one(atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
_Mem->notify_one();
}
template <class _Ty>
void atomic_notify_all(volatile atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
_Mem->notify_all();
}
template <class _Ty>
void atomic_notify_all(atomic<_Ty>* const _Mem) noexcept /* strengthened */ {
_Mem->notify_all();
}
#endif // _HAS_CXX20
using atomic_bool = atomic<bool>;
using atomic_char = atomic<char>;
using atomic_schar = atomic<signed char>;
using atomic_uchar = atomic<unsigned char>;
using atomic_short = atomic<short>;
using atomic_ushort = atomic<unsigned short>;
using atomic_int = atomic<int>;
using atomic_uint = atomic<unsigned int>;
using atomic_long = atomic<long>;
using atomic_ulong = atomic<unsigned long>;
using atomic_llong = atomic<long long>;
using atomic_ullong = atomic<unsigned long long>;
#ifdef __cpp_lib_char8_t
using atomic_char8_t = atomic<char8_t>;
#endif // __cpp_lib_char8_t
using atomic_char16_t = atomic<char16_t>;
using atomic_char32_t = atomic<char32_t>;
using atomic_wchar_t = atomic<wchar_t>;
using atomic_int8_t = atomic<int8_t>;
using atomic_uint8_t = atomic<uint8_t>;
using atomic_int16_t = atomic<int16_t>;
using atomic_uint16_t = atomic<uint16_t>;
using atomic_int32_t = atomic<int32_t>;
using atomic_uint32_t = atomic<uint32_t>;
using atomic_int64_t = atomic<int64_t>;
using atomic_uint64_t = atomic<uint64_t>;
using atomic_int_least8_t = atomic<int_least8_t>;
using atomic_uint_least8_t = atomic<uint_least8_t>;
using atomic_int_least16_t = atomic<int_least16_t>;
using atomic_uint_least16_t = atomic<uint_least16_t>;
using atomic_int_least32_t = atomic<int_least32_t>;
using atomic_uint_least32_t = atomic<uint_least32_t>;
using atomic_int_least64_t = atomic<int_least64_t>;
using atomic_uint_least64_t = atomic<uint_least64_t>;
using atomic_int_fast8_t = atomic<int_fast8_t>;
using atomic_uint_fast8_t = atomic<uint_fast8_t>;
using atomic_int_fast16_t = atomic<int_fast16_t>;
using atomic_uint_fast16_t = atomic<uint_fast16_t>;
using atomic_int_fast32_t = atomic<int_fast32_t>;
using atomic_uint_fast32_t = atomic<uint_fast32_t>;
using atomic_int_fast64_t = atomic<int_fast64_t>;
using atomic_uint_fast64_t = atomic<uint_fast64_t>;
using atomic_intptr_t = atomic<intptr_t>;
using atomic_uintptr_t = atomic<uintptr_t>;
using atomic_size_t = atomic<size_t>;
using atomic_ptrdiff_t = atomic<ptrdiff_t>;
using atomic_intmax_t = atomic<intmax_t>;
using atomic_uintmax_t = atomic<uintmax_t>;
#if _HAS_CXX20
// Though there are CMPXCHG8B and CMPXCHG16B,
// the largest atomics with a full set of efficient operations are pointer-sized.
using atomic_signed_lock_free = atomic_intptr_t;
using atomic_unsigned_lock_free = atomic_uintptr_t;
#endif // _HAS_CXX20
#if _HAS_CXX20
_NODISCARD inline bool atomic_flag_test(const volatile atomic_flag* const _Flag) noexcept {
return _Flag->test();
}
_NODISCARD inline bool atomic_flag_test(const atomic_flag* const _Flag) noexcept {
return _Flag->test();
}
_NODISCARD inline bool atomic_flag_test_explicit(
const volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
return _Flag->test(_Order);
}
_NODISCARD inline bool atomic_flag_test_explicit(const atomic_flag* const _Flag, const memory_order _Order) noexcept {
return _Flag->test(_Order);
}
#endif // _HAS_CXX20
inline bool atomic_flag_test_and_set(atomic_flag* const _Flag) noexcept {
return _Flag->test_and_set();
}
inline bool atomic_flag_test_and_set(volatile atomic_flag* const _Flag) noexcept {
return _Flag->test_and_set();
}
inline bool atomic_flag_test_and_set_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
return _Flag->test_and_set(_Order);
}
inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
return _Flag->test_and_set(_Order);
}
inline void atomic_flag_clear(atomic_flag* const _Flag) noexcept {
_Flag->clear();
}
inline void atomic_flag_clear(volatile atomic_flag* const _Flag) noexcept {
_Flag->clear();
}
inline void atomic_flag_clear_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
_Flag->clear(_Order);
}
inline void atomic_flag_clear_explicit(volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
_Flag->clear(_Order);
}
#if _HAS_CXX20
inline void atomic_flag_wait(const volatile atomic_flag* const _Flag, const bool _Expected) noexcept {
return _Flag->wait(_Expected);
}
inline void atomic_flag_wait(const atomic_flag* const _Flag, const bool _Expected) noexcept {
return _Flag->wait(_Expected);
}
inline void atomic_flag_wait_explicit(
const volatile atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
return _Flag->wait(_Expected, _Order);
}
inline void atomic_flag_wait_explicit(
const atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
return _Flag->wait(_Expected, _Order);
}
inline void atomic_flag_notify_one(volatile atomic_flag* const _Flag) noexcept {
return _Flag->notify_one();
}
inline void atomic_flag_notify_one(atomic_flag* const _Flag) noexcept {
return _Flag->notify_one();
}
inline void atomic_flag_notify_all(volatile atomic_flag* const _Flag) noexcept {
return _Flag->notify_all();
}
inline void atomic_flag_notify_all(atomic_flag* const _Flag) noexcept {
return _Flag->notify_all();
}
template <class _Ty>
class _Locked_pointer
{
public:
static_assert(alignof(_Ty) >= (1 << 2), "2 low order bits are needed by _Locked_pointer");
static constexpr uintptr_t _Lock_mask = 3;
static constexpr uintptr_t _Not_locked = 0;
static constexpr uintptr_t _Locked_notify_not_needed = 1;
static constexpr uintptr_t _Locked_notify_needed = 2;
static constexpr uintptr_t _Ptr_value_mask = ~_Lock_mask;
constexpr _Locked_pointer() noexcept : _Storage{} {}
explicit _Locked_pointer(_Ty* const _Ptr) noexcept : _Storage{reinterpret_cast<uintptr_t>(_Ptr)} {}
_Locked_pointer(const _Locked_pointer&) = delete;
_Locked_pointer& operator=(const _Locked_pointer&) = delete;
_NODISCARD _Ty* _Lock_and_load() noexcept {
uintptr_t _Rep = _Storage.load(memory_order_relaxed);
for (;;) {
switch (_Rep & _Lock_mask) {
case _Not_locked: // Can try to lock now
if (_Storage.compare_exchange_weak(_Rep, _Rep | _Locked_notify_not_needed)) {
return reinterpret_cast<_Ty*>(_Rep);
}
_YIELD_PROCESSOR();
break;
case _Locked_notify_not_needed: // Try to set "notify needed" and wait
if (!_Storage.compare_exchange_weak(_Rep, (_Rep & _Ptr_value_mask) | _Locked_notify_needed)) {
// Failed to set notify needed flag, try again
_YIELD_PROCESSOR();
break;
}
_Rep = (_Rep & _Ptr_value_mask) | _Locked_notify_needed;
[[fallthrough]];
case _Locked_notify_needed: // "Notify needed" is already set, just wait
_Storage.wait(_Rep, memory_order_relaxed);
_Rep = _Storage.load(memory_order_relaxed);
break;
default: // Unrecognized bit pattern
_CSTD abort();
}
}
}
void _Store_and_unlock(_Ty* const _Value) noexcept {
const auto _Rep = _Storage.exchange(reinterpret_cast<uintptr_t>(_Value));
if ((_Rep & _Lock_mask) == _Locked_notify_needed) {
// As we don't count waiters, every waiter is notified, and then some may re-request notification
_Storage.notify_all();
}
}
_NODISCARD _Ty* _Unsafe_load_relaxed() const noexcept {
return reinterpret_cast<_Ty*>(_Storage.load(memory_order_relaxed));
}
private:
atomic<uintptr_t> _Storage;
};
#endif // _HAS_CXX20
_STD_END
// #define _STD_END } ，在 std 命名空间里的操作结束
#undef _CMPXCHG_MASK_OUT_PADDING_BITS
#undef _ATOMIC_CHOOSE_INTRINSIC
#undef _ATOMIC_HAS_DCAS
#undef _STD_COMPARE_EXCHANGE_128
#undef _INVALID_MEMORY_ORDER
#undef _Compiler_or_memory_barrier
#undef _Memory_barrier
#undef _Compiler_barrier
#pragma pop_macro("new")
// 恢复最开始隐藏的 new 宏定义，#pragma push_macro("new")
_STL_RESTORE_CLANG_WARNINGS
// 对应最开始的，此处是恢复 clang 警告
#pragma warning(pop)
// 恢复原来的警告级别 #pragma warning(push, _STL_WARNING_LEVEL)
#pragma pack(pop)
// 恢复原来的内存对齐方式 #pragma pack(push, _CRT_PACKING)
#endif // _STL_COMPILER_PREPROCESSOR，本文件在此 #if 成立时才存在
#endif // _ATOMIC_
（88） 至此，对该头文件的阅读就结束了，告一段落了，愿所有人越来越好 。
谢谢
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
