當(dāng)前位置：首頁(yè) > 编程语言 > c/c++ >内容正文

c/c++

atomic头文件编译_c++11 多线程（3）atomic 总结

發(fā)布時(shí)間：2023/12/16 c/c++ 24 豆豆

生活随笔收集整理的這篇文章主要介紹了 atomic头文件编译_c++11 多线程（3）atomic 总结小編覺(jué)得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

一、頭文件結(jié)構(gòu)

頭文件：原子類型是封裝了一個(gè)值的類型，它的訪問(wèn)保證不會(huì)導(dǎo)致數(shù)據(jù)的競(jìng)爭(zhēng)，并且可以用于在不同的線程之間同步內(nèi)存訪問(wèn)。

這個(gè)頭聲明了兩個(gè)c++類，原子和atomic_flag，它實(shí)現(xiàn)了自包含類中的原子類型的所有特性。header還聲明了整個(gè)C樣式類型和函數(shù)與C中的原子支持兼容。頭文件中結(jié)構(gòu)定義查看。

頭文件的結(jié)構(gòu)：

class

用于bool、整數(shù)和指針類型的原子類模板和特殊化 (類模板)

無(wú)鎖布爾原子類型(類)

Types

為給定的原子操作定義內(nèi)存排序約束(typedef)

Typedefs

std::atomic_bool

std::atomic

std::atomic_char

std::atomic

std::atomic_schar

std::atomic

std::atomic_uchar

std::atomic

std::atomic_short

std::atomic

std::atomic_ushort

std::atomic

std::atomic_int

std::atomic

std::atomic_uint

std::atomic

std::atomic_long

std::atomic

std::atomic_ulong

std::atomic

std::atomic_llong

std::atomic

std::atomic_ullong

std::atomic

std::atomic_char16_t

std::atomic

std::atomic_char32_t

std::atomic

std::atomic_wchar_t

std::atomic

std::atomic_int_least8_t

std::atomic

std::atomic_uint_least8_t

std::atomic

std::atomic_int_least16_t

std::atomic

std::atomic_uint_least16_t

std::atomic

std::atomic_int_least32_t

std::atomic

std::atomic_uint_least32_t

std::atomic

std::atomic_int_least64_t

std::atomic

std::atomic_uint_least64_t

std::atomic

std::atomic_int_fast8_t

std::atomic

std::atomic_uint_fast8_t

std::atomic

std::atomic_int_fast16_t

std::atomic

std::atomic_uint_fast16_t

std::atomic

std::atomic_int_fast32_t

std::atomic

std::atomic_uint_fast32_t

std::atomic

std::atomic_int_fast64_t

std::atomic

std::atomic_uint_fast64_t

std::atomic

std::atomic_intptr_t

std::atomic

std::atomic_uintptr_t

std::atomic

std::atomic_size_t

std::atomic

std::atomic_ptrdiff_t

std::atomic

std::atomic_intmax_t

std::atomic

std::atomic_uintmax_t

std::atomic

Functions for atomic flags (C-style)

description

Preprocessor macros

description

靜態(tài)存儲(chǔ)時(shí)間的原子變量的常量初始化(宏)

初始化 std::atomic_flag為 false

Macro constants

// lock-free property

#define ATOMIC_BOOL_LOCK_FREE /*unspecified*/

#define ATOMIC_CHAR_LOCK_FREE /*unspecified*/

#define ATOMIC_CHAR16_T_LOCK_FREE /*unspecified*/

#define ATOMIC_CHAR32_T_LOCK_FREE /*unspecified*/

#define ATOMIC_WCHAR_T_LOCK_FREE /*unspecified*/

#define ATOMIC_SHORT_LOCK_FREE /*unspecified*/

#define ATOMIC_INT_LOCK_FREE /*unspecified*/

#define ATOMIC_LONG_LOCK_FREE /*unspecified*/

#define ATOMIC_LLONG_LOCK_FREE /*unspecified*/

#define ATOMIC_POINTER_LOCK_FREE /*unspecified*/

上面是對(duì)頭文件結(jié)構(gòu)的描述；下面具體按照上面的結(jié)構(gòu)分析：

定義： //類模版

template< class T > struct atomic; (1) (since C++11)

template<> struct atomic; (2) (since C++11)

template<> struct atomic; (3) (since C++11)

template< class T > struct atomic; (4) (since C++11) 指針特化

std::atomic模板的每個(gè)實(shí)例化和專門化都定義了一個(gè)原子類型。如果一個(gè)線程在另一個(gè)線程讀取它時(shí)寫入一個(gè)原子對(duì)象，那么行為就會(huì)被明確定義(參見關(guān)于數(shù)據(jù)競(jìng)爭(zhēng)的詳細(xì)信息的內(nèi)存模型)。此外，對(duì)原子對(duì)象的訪問(wèn)可以建立線程間的同步，并按照std::memoryorder指定非原子性的內(nèi)存訪問(wèn)。

std::atomic可以用任何簡(jiǎn)單的可復(fù)制的t實(shí)例化。同時(shí)std::atomic是不可復(fù)制的，也不是可移動(dòng)的。

Member functions

atomic() noexcept = default;(1) default (since C++11)

constexpr atomic( T desired ) noexcept;(2) initialization (since C++11)

atomic( const atomic& ) = delete;(3) copy [deleted] (since C++11)

構(gòu)造新的原子變量。

1)將原子對(duì)象放在未初始化的狀態(tài)中。一個(gè)未初始化的原子對(duì)象可以通過(guò)調(diào)用atomicinit來(lái)初始化。

2)用desired 初始化對(duì)象。初始化不是原子性的。

3)原子變量不是可復(fù)制的。

示例1：

// constructing atomics

#include // std::cout

#include // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT

#include // std::thread, std::this_thread::yield

#include // std::vector

std::atomic ready (false);

std::atomic_flag winner = ATOMIC_FLAG_INIT;

void count1m (int id) {

while (!ready) { std::this_thread::yield(); } // wait for the ready signal

for (volatile int i=0; i<1000000; ++i) {} // go!, count to 1 million

if (!winner.test_and_set()) { std::cout << "thread #" << id << " won!\n"; }

};

int main ()

{

std::vector<:thread> threads;

std::cout << "spawning 10 threads that count to 1 million...\n";

for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));

ready = true;

for (auto& th : threads) th.join();

return 0;

}

T operator=( T desired ) noexcept; set value (1)

T operator=( T desired ) volatile noexcept; set value (1)

atomic& operator=( const atomic& ) = delete; copy [deleted] (2)

atomic& operator=( const atomic& ) volatile = delete; copy [deleted] (2)

1 用val替換存儲(chǔ)的值。該操作是原子性的，并使用順序一致性(memoryorderseqcst)。要使用不同的內(nèi)存排序來(lái)修改值，請(qǐng)參見atomic::store。

2 原子對(duì)象沒(méi)有定義的復(fù)制賦值，但是注意它們是可以隱式地轉(zhuǎn)換為類型T。

注意：與大多數(shù)賦值運(yùn)算符不同，原子類型的賦值運(yùn)算符不會(huì)返回對(duì)它們的左參數(shù)的引用。它們返回一個(gè)存儲(chǔ)值的副本。

示例2：

// atomic::operator=/operator T example:

#include // std::cout

#include // std::atomic

#include // std::thread, std::this_thread::yield

std::atomic foo(0);

void set_foo(int x) {

foo = x;

}

void print_foo() {

while (foo==0) { // wait while foo=0

std::this_thread::yield();

}

std::cout << "foo: " << foo << '\n';

}

int main ()

{

std::thread first (print_foo);

std::thread second (set_foo,10);

first.join();

second.join();

return 0;

}

General atomic operations

bool is_lock_free() const noexcept;

bool is_lock_free() const volatile noexcept;

一個(gè)無(wú)鎖對(duì)象并不會(huì)導(dǎo)致其他線程在訪問(wèn)時(shí)被阻塞(可能使用某種類型的事務(wù)性內(nèi)存)。該函數(shù)返回的值與相同類型的所有其他對(duì)象返回的值一致。

檢查這個(gè)類型的所有對(duì)象的原子操作是否都是無(wú)鎖的。返回true表示lock_free.

示例3：

#include

struct A { int a[100]; };

struct B { int x, y; };

int main()

{

std::cout << std::boolalpha

<< "std::atomic is lock free? "

<< std::atomic{}.is_lock_free() << '\n'

<< "std::atomic is lock free? "

<< std::atomic{}.is_lock_free() << '\n';

return 0;

}

void store (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

void store (T val, memory_order sync = memory_order_seq_cst) noexcept;

用val替換包含的值。操作是原子的，按照同步所指定的內(nèi)存順序內(nèi)存數(shù)序包括(std::memory_order_relaxed, std::memory_order_release 和std::memory_order_seq_cst)。

參數(shù)sync的描述(后續(xù)會(huì)介紹memory_order)：

memory_order_relaxed：不同步副作用。

memory_order_release：同步下一個(gè)使用或者獲取操作的副作用。

memory_order_seq_cst：同步所有與其他順序一致操作的可見的副作用，并遵循一個(gè)完整的順序。

示例4：

// atomic::load/store example

#include // std::cout

#include // std::atomic, std::memory_order_relaxed

#include // std::thread

std::atomic foo (0);

void set_foo(int x) {

foo.store(x,std::memory_order_relaxed); // set value atomically

}

void print_foo() {

int x;

do {

x = foo.load(std::memory_order_relaxed); // get value atomically

} while (x==0);

std::cout << "foo: " << x << '\n';

}

int main ()

{

std::thread first (print_foo);

std::thread second (set_foo,10);

first.join();

second.join();

return 0;

}

T load (memory_order sync = memory_order_seq_cst) const volatile noexcept;

T load (memory_order sync = memory_order_seq_cst) const noexcept;

返回包含值。操作是原子的，按照同步所指定的內(nèi)存順序。指令必須是std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire 和 std::memory_order_seq_cst)；否則，行為是沒(méi)有定義的。

sync指令描述：

上文已經(jīng)描述了std::memory_order_relaxed和 std::memory_order_seq_cst，這里只描述memory_order_acquire和memory_order_consume。

memory_order_acquire：同步從最后一個(gè)Release或順序一致的操作所有可見的副作用。

memory_order_consume：同步與最后一個(gè)Release或順序一致的操作所產(chǎn)生的依賴關(guān)系的可見的副作用。

示例5：

// atomic::load/store example

#include // std::cout

#include // std::atomic, std::memory_order_relaxed

#include // std::thread

std::atomic foo (0);

void set_foo(int x) {

foo.store(x,std::memory_order_relaxed); // set value atomically

}

void print_foo() {

int x;

do {

x = foo.load(std::memory_order_relaxed); // get value atomically

} while (x==0);

std::cout << "foo: " << x << '\n';

}

int main ()

{

std::thread first (print_foo);

std::thread second (set_foo,10);

first.join();

second.join();

return 0;

}

operator T() const volatile noexcept;

operator T() const noexcept;

這是一個(gè)類型轉(zhuǎn)換的操作符:這個(gè)表達(dá)式期望它包含的類型(T)的值，調(diào)用這個(gè)成員函數(shù)，訪問(wèn)包含的值。

該操作是原子的，并使用順序一致性(memory_order_seq_cst)。要檢索具有不同內(nèi)存順序的值，相當(dāng)于std::atomic::load。

示例6：

// atomic::operator=/operator T example:

#include // std::cout

#include // std::atomic

#include // std::thread, std::this_thread::yield

std::atomic foo(0);

std::atomic bar(0);

void set_foo(int x) {

foo = x;

}

void copy_foo_to_bar () {

while (foo==0) std::this_thread::yield();

bar = static_cast(foo);

}

void print_bar() {

while (bar==0) std::this_thread::yield();

std::cout << "bar: " << bar << '\n';

}

int main ()

{

std::thread first (print_bar);

std::thread second (set_foo,10);

std::thread third (copy_foo_to_bar);

first.join();

second.join();

third.join();

return 0;

}

T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept;

訪問(wèn)和修改包含的值

用val替換所包含的值，并返回它之前的值。整個(gè)操作是原子性的(一個(gè)原子的讀-修改-寫操作):在讀取(返回)值和被該函數(shù)修改的那一刻之間，值不會(huì)受到其他線程的影響。

sync指令描述：

上文已經(jīng)描述了std::memory_order_relaxed和 std::memory_order_seq_cst 和memory_order_consume 和 memory_order_acquire，這里只描述memory_order_acq_rel。

memory_order_acq_rel：讀取作為一個(gè)獲取操作，并作為一個(gè)發(fā)布操作寫入。

示例 7：

// atomic::exchange example

#include // std::cout

#include // std::atomic

#include // std::thread

#include // std::vector

std::atomic ready (false);

std::atomic winner (false);

void count1m (int id) {

while (!ready) {} // wait for the ready signal

for (int i=0; i<1000000; ++i) {} // go!, count to 1 million

if (!winner.exchange(true)) { std::cout << "thread #" << id << " won!\n"; }

};

int main ()

{

std::vector<:thread> threads;

std::cout << "spawning 10 threads that count to 1 million...\n";

for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));

ready = true;

for (auto& th : threads) th.join();

return 0;

}

bool compare_exchange_weak (T& expected, T val,

memory_order sync = memory_order_seq_cst) volatile noexcept; (1)

bool compare_exchange_weak (T& expected, T val,

memory_order sync = memory_order_seq_cst) noexcept; (1)

bool compare_exchange_weak (T& expected, T val,

memory_order success, memory_order failure) volatile noexcept; (2)

bool compare_exchange_weak (T& expected, T val,

memory_order success, memory_order failure) noexcept; (2)

bool compare_exchange_strong (T& expected, T val,

memory_order sync = memory_order_seq_cst) volatile noexcept; (1)

bool compare_exchange_strong (T& expected, T val,

memory_order sync = memory_order_seq_cst) noexcept; (1)

bool compare_exchange_strong (T& expected, T val,

memory_order success, memory_order failure) volatile noexcept; (2)

bool compare_exchange_strong (T& expected, T val,

memory_order success, memory_order failure) noexcept; (2)

* 比較原子對(duì)象的包含值與預(yù)期的內(nèi)容:

--1 如果是真的，它會(huì)用val替換包含的值(比如存儲(chǔ))。

--2 如果是假的，它會(huì)用所包含的值替換預(yù)期,因此調(diào)用該函數(shù)之后，如果被該原子對(duì)象封裝的值與參數(shù) expected 所指定的值不相等，expected 中的內(nèi)容就是原子對(duì)象的舊值。

* 函數(shù)總是訪問(wèn)包含的值來(lái)讀取它，如果這個(gè)比較是真的，那么它也會(huì)替換它。但是整個(gè)操作都是原子性的:在讀取值和被替換的時(shí)刻之間，它的值不能被其他線程修改。

* 在第(2)種情況下，內(nèi)存序(Memory Order)的選擇取決于比較操作結(jié)果，如果比較結(jié)果為 true(即原子對(duì)象的值等于 expected)，則選擇參數(shù) success 指定的內(nèi)存序，否則選擇參數(shù) failure 所指定的內(nèi)存序。

** 注意：

這個(gè)函數(shù)直接的比較物理內(nèi)容所包含的價(jià)值與預(yù)期的內(nèi)容,這可能導(dǎo)致得到使用operator==比較的結(jié)果是一個(gè)失敗的結(jié)果,因?yàn)閷?duì)象底層的物理內(nèi)容中可能存在位對(duì)齊或其他邏輯表示相同但是物理表示不同的值(比如 true 和 2 或 3，它們?cè)谶壿嬌隙急硎?#34;真"，但在物理上兩者的表示并不相同)。

不像 compare_exchange_strong，這個(gè)弱版本允許(spuriously 地)返回 false(即原子對(duì)象所封裝的值與參數(shù) expected 的物理內(nèi)容相同，但卻仍然返回 false)，即使在預(yù)期的實(shí)際情況與所包含的對(duì)象相比較時(shí)也是如此。對(duì)于某些循環(huán)算法來(lái)說(shuō)，這可能是可接受的行為，并且可能會(huì)在某些平臺(tái)上帶來(lái)顯著的性能提升。在這些虛假的失敗中，函數(shù)返回false，而不修改預(yù)期。

對(duì)于非循環(huán)算法來(lái)說(shuō)， compare_exchange_strong通常是首選。

示例8：

// atomic::compare_exchange_weak example:

#include // std::cout

#include // std::atomic

#include // std::thread

#include // std::vector

// a simple global linked list:

struct Node { int value; Node* next; };

std::atomic list_head (nullptr);

void append (int val) { // append an element to the list

Node* oldHead = list_head;

Node* newNode = new Node {val,oldHead};

// what follows is equivalent to: list_head = newNode, but in a thread-safe way:

while (!list_head.compare_exchange_weak(oldHead,newNode))

newNode->next = oldHead;

}

int main ()

{

// spawn 10 threads to fill the linked list:

std::vector<:thread> threads;

for (int i=0; i<10; ++i) threads.push_back(std::thread(append,i));

for (auto& th : threads) th.join();

// print contents:

for (Node* it = list_head; it!=nullptr; it=it->next)

std::cout << ' ' << it->value;

std::cout << '\n';

// cleanup:

Node* it; while (it=list_head) {list_head=it->next; delete it;}

return 0;

}

compare_exchange_strong 跟 compare_exchange_week 不同的是：

與compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允許(spuriously 地)返回 false，即原子對(duì)象所封裝的值與參數(shù) expected 的物理內(nèi)容相同，比較操作一定會(huì)為 true。不過(guò)在某些平臺(tái)下，如果算法本身需要循環(huán)操作來(lái)做檢查， compare_exchange_weak 的性能會(huì)更好。

特定的操作支持(整形和指針)

if T is integral (1)

T fetch_add (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_add (T val, memory_order sync = memory_order_seq_cst) noexcept;

T fetch_sub (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_sub (T val, memory_order sync = memory_order_seq_cst) noexcept;

if T is pointer (2)

T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_add (ptrdiff_t val, memory_order sync = memory_order_seq_cst) noexcept;

T fetch_sub (ptrdiff_t val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_sub (ptrdiff_t val, memory_order sync = memory_order_seq_cst) noexcept;

*將val加或者減去到包含的值并返回在操作之前的值。

*整個(gè)操作是原子的(一個(gè)原子的讀-修改-寫操作):當(dāng)在這個(gè)函數(shù)被修改的時(shí)候,讀取的(返回)值被讀取，值不受其他線程的影響。

*這個(gè)成員函數(shù)是對(duì)整數(shù)(1)和指針(2)類型(除了bool除外)的原子專門化中定義。

*如果第二個(gè)參數(shù)使用默認(rèn)值，則該函數(shù)等價(jià)于原子::運(yùn)算符+ =。

示例9：

#include

std::atomic data;

void do_work()

{

data.fetch_add(1, std::memory_order_relaxed);

}

int main()

{

std::thread th1(do_work);

std::thread th2(do_work);

std::thread th3(do_work);

std::thread th4(do_work);

std::thread th5(do_work);

th1.join();

th2.join();

th3.join();

th4.join();

th5.join();

std::cout << "Result:" << data << '\n';

return 0;

}

T fetch_and (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_and (T val, memory_order sync = memory_order_seq_cst) noexcept;

T fetch_or (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_or (T val, memory_order sync = memory_order_seq_cst) noexcept;

T fetch_xor (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;

T fetch_xor (T val, memory_order sync = memory_order_seq_cst) noexcept;

* 讀取包含的值并替換調(diào)該值和val執(zhí)行一個(gè)位和操作的結(jié)果。

* 整個(gè)操作是原子的(一個(gè)原子的讀-修改-寫操作):當(dāng)在這個(gè)函數(shù)被修改的時(shí)候,讀取的(返回)值被讀取，值不受其他線程的影響。

* 這個(gè)成員函數(shù)只在原子專門化中定義為整數(shù)類型(除了bool)。

* 如果第二個(gè)參數(shù)使用默認(rèn)值，則該函數(shù)等價(jià)于原子::operator& =。

T operator++() volatile noexcept;

T operator++() noexcept;

T operator--() volatile noexcept;

T operator--() noexcept;

post-increment (2)

T operator++ (int) volatile noexcept;

T operator++ (int) noexcept;

T operator-- (int) volatile noexcept;

T operator-- (int) noexcept;

* 包含值的值進(jìn)行增加或減少1，操作(1)返回所得到的包含值，操作(2)返回之前的值。

* 整個(gè)操作是原子的(一個(gè)原子的讀-修改-寫操作):當(dāng)在這個(gè)函數(shù)被修改的時(shí)候,讀取的(返回)值被讀取，值不受其他線程的影響。

* 函數(shù)只在原子專門化中定義為整數(shù)和指針類型(除了bool)。

* 這個(gè)函數(shù)的行為就像調(diào)用std::stomic::fetch_add(1),memory_order_seq_cst作為參數(shù)。

if T is integral (1)

T operator+= (T val) volatile noexcept;

T operator+= (T val) noexcept;

T operator-= (T val) volatile noexcept;

T operator-= (T val) noexcept;

T operator&= (T val) volatile noexcept;

T operator&= (T val) noexcept;

T operator|= (T val) volatile noexcept;

T operator|= (T val) noexcept;

T operator^= (T val) volatile noexcept;

T operator^= (T val) noexcept;

if T is pointer (2)

T operator+= (ptrdiff_t val) volatile noexcept;

T operator+= (ptrdiff_t val) noexcept;

T operator-= (ptrdiff_t val) volatile noexcept;

T operator-= (ptrdiff_t val) noexcept;

* 對(duì)于整形(1)和指針(2)類型的原子專門化是支持復(fù)合賦值的;每一個(gè)函數(shù)都訪問(wèn)包含的值，應(yīng)用合適的操作符，并在操作之前返回包含值的值;所有這些操作都不會(huì)受到其他線程的影響。

* 這些函數(shù)的行為就像使用memory_order_seq_cst調(diào)用std::stomic::fetch_ *函數(shù)一樣:

atomic_flag是一個(gè)原子布爾類型。不同于std::atomic的所有專門化，它保證是lock_free。不像std::stomic< bool >，std::atomic_flag不提供負(fù)載或存儲(chǔ)操作。

示例10：

#include

std::atomic_flag lock = ATOMIC_FLAG_INIT;

void f(int n)

{

for (int cnt = 0; cnt < 100; ++cnt) {

while (lock.test_and_set(std::memory_order_acquire)) // acquire lock

; // spin

std::cout << "Output from thread " << n << '\n';

lock.clear(std::memory_order_release); // release lock

}

int main()

{

std::vector<:thread> v;

for (int n = 0; n < 10; ++n) {

v.emplace_back(f, n);

}

for (auto& t : v) {

t.join();

}

return 0;

}

atomic_flag() noexcept = default;

atomic_flag (const atomic_flag&T) = delete;

* atomic_flag在構(gòu)建(或設(shè)置或清除)上處于一個(gè)未指定的狀態(tài)，除非它被顯式地初始化為ATOMIC_FLAG_INIT。

* ATOMIC_FLAG_INIT初始化是通過(guò)簡(jiǎn)單地調(diào)用默認(rèn)構(gòu)造函數(shù)或其他方法來(lái)實(shí)現(xiàn)的，這取決于特定的庫(kù)實(shí)現(xiàn)。

* atomic_flag值不能復(fù)制/移動(dòng)。

*** 注意： std::atomic_flag::operator= 不可賦值，其賦值操作符被刪除。。

示例11：

// constructing atomics: atomic vs atomic_flag

#include // std::cout

#include // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT

#include // std::thread, std::this_thread::yield

#include // std::vector

std::atomic ready (false); // can be checked without being set

std::atomic_flag winner = ATOMIC_FLAG_INIT; // always set when checked

void count1m (int id) {

while (!ready) { std::this_thread::yield(); } // wait for the ready signal

for (int i=0; i<1000000; ++i) {} // go!, count to 1 million

if (!winner.test_and_set()) { std::cout << "thread #" << id << " won!\n"; }

};

int main ()

{

std::vector<:thread> threads;

std::cout << "spawning 10 threads that count to 1 million...\n";

for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));

ready = true;

for (auto& th : threads) th.join();

return 0;

}

bool test_and_set (memory_order sync = memory_order_seq_cst) volatile noexcept;

bool test_and_set (memory_order sync = memory_order_seq_cst) noexcept;

* 設(shè)置atomic_flag并返回是否在調(diào)用之前已經(jīng)設(shè)置的。

* * 整個(gè)操作是原子的(一個(gè)原子的讀-修改-寫操作):當(dāng)在這個(gè)函數(shù)被修改的時(shí)候,讀取的(返回)值被讀取，值不受其他線程的影響。

示例12：

// atomic_flag as a spinning lock

#include // std::cout

#include // std::atomic_flag

#include // std::thread

#include // std::vector

#include // std::stringstream

std::atomic_flag lock_stream = ATOMIC_FLAG_INIT;

std::stringstream stream;

void append_number(int x) {

while (lock_stream.test_and_set()) {}

stream << "thread #" << x << '\n';

lock_stream.clear();

}

int main ()

{

std::vector<:thread> threads;

for (int i=1; i<=10; ++i) threads.push_back(std::thread(append_number,i));

for (auto& th : threads) th.join();

std::cout << stream.str();

return 0;

}

void clear (memory_order sync = memory_order_seq_cst) volatile noexcept;

void clear (memory_order sync = memory_order_seq_cst) noexcept;

清除atomic_flag(即把a(bǔ)tomic_flag 設(shè)為假)。

清除atomic_flag使下一次調(diào)用成員atomic_flag::test_and_set對(duì)象返回false。

操作是原子的，按照sync所指定的內(nèi)存順序。

示例13：

// atomic_flag as a spinning lock

#include // std::cout

#include // std::atomic_flag

#include // std::thread

#include // std::vector

#include // std::stringstream

std::atomic_flag lock_stream = ATOMIC_FLAG_INIT;

std::stringstream stream;

void append_number(int x) {

while (lock_stream.test_and_set()) {}

stream << "thread #" << x << '\n';

lock_stream.clear();

}

int main ()

{

std::vector<:thread> threads;

for (int i=1; i<=10; ++i) threads.push_back(std::thread(append_number,i));

for (auto& th : threads) th.join();

std::cout << stream.str();

return 0;

}

作為用于執(zhí)行原子操作的函數(shù)的參數(shù)，用于指定如何同步不同線程上的其他操作。也可參見網(wǎng)址。

定義：

```c

typedef enum memory_order {

memory_order_relaxed, // relaxed

memory_order_consume, // consume

memory_order_acquire, // acquire

memory_order_release, // release

memory_order_acq_rel, // acquire/release

memory_order_seq_cst // sequentially consistent

} memory_order;

* 當(dāng)多個(gè)線程訪問(wèn)原子對(duì)象時(shí)，所有原子操作都會(huì)對(duì)一個(gè)原子對(duì)象定義良好的行為:在任何其他原子操作能夠訪問(wèn)該對(duì)象之前，每個(gè)原子操作都是完全在對(duì)象上執(zhí)行的。這保證了這些對(duì)象上沒(méi)有數(shù)據(jù)競(jìng)爭(zhēng)，而這正是定義原子性的特性。

* 但是，每個(gè)線程可能在內(nèi)存位置上執(zhí)行操作，而不是原子對(duì)象本身:這些操作可能會(huì)對(duì)其他線程產(chǎn)生可見的副作用。這種類型的參數(shù)允許指定操作的內(nèi)存順序，以確定這些(可能非原子)可見的副作用是如何在線程間同步的，使用原子操作作為同步點(diǎn):

memory_order_relaxed

該操作在某一時(shí)刻被命令進(jìn)行原子化。這是最寬松的內(nèi)存順序，無(wú)法保證對(duì)不同線程的內(nèi)存訪問(wèn)是如何根據(jù)原子操作進(jìn)行排序的。

標(biāo)記為memory_order_relaxed的原子操作不是同步操作;它們不會(huì)在并發(fā)內(nèi)存訪問(wèn)中強(qiáng)制執(zhí)行順序。它們只保證原子性和修改順序的一致性。

示例14：

#include

std::atomic cnt = {0};

void f()

{

for (int n = 0; n < 1000; ++n) {

cnt.fetch_add(1, std::memory_order_relaxed);

}

int main()

{

std::vector<:thread> v;

for (int n = 0; n < 10; ++n) {

v.emplace_back(f);

}

for (auto& t : v) {

t.join();

}

std::cout << "Final counter value is " << cnt << '\n';

return 0;

}

memory_order_consume

如果在這個(gè)對(duì)釋放操作進(jìn)行依賴(并且對(duì)加載線程有明顯的副作用)的釋放線程上所有訪問(wèn)內(nèi)存已經(jīng)發(fā)生，那么操作將被命令執(zhí)行。

帶有這個(gè)內(nèi)存順序的加載操作在受影響的內(nèi)存位置上執(zhí)行獲取操作:當(dāng)前線程依賴于當(dāng)前裝載的值，在此負(fù)載之前，不需要讀取或?qū)懭搿Ｔ诋?dāng)前線程中可以看到相同的原子變量。在大多數(shù)平臺(tái)上，這只會(huì)影響編譯器優(yōu)化(參見下面的Release-Consume)。

memory_order_acquire

在釋放線程(對(duì)加載線程有明顯的副作用)的情況下，操作被命令進(jìn)行一次。

帶有這個(gè)內(nèi)存順序的加載操作在受影響的內(nèi)存位置上執(zhí)行獲取操作:在此負(fù)載之前，在當(dāng)前線程中不可以重新排序。所有在其他線程中都可以在當(dāng)前線程中看到相同的原子變量(參見下面的Release-Acquire)

memory_order_release

* 該操作被命令在消費(fèi)或獲取操作之前發(fā)生，作為對(duì)內(nèi)存的其他訪問(wèn)的同步點(diǎn)，可能對(duì)加載線程有可見的副作用。

* 具有這種內(nèi)存順序的存儲(chǔ)操作執(zhí)行釋放操作:在當(dāng)前線程中，在該存儲(chǔ)之后，不可以在當(dāng)前線程中重新排序。當(dāng)前線程中所有的寫操作都可以在其他線程中看到，這些線程獲得相同的原子變量(參見下面的Release-Acquire)，并且在使用相同原子的其他線程中，將對(duì)原子變量的依賴變?yōu)榭梢?參見下面的Release-Consume)。

memory_order_acq_rel

* 該操作加載并存儲(chǔ)釋放(如上所述，用于memory_order_acquire 、memory_order_release)。

memory_order_seq_cst

* 這個(gè)操作是按順序一致的方式排序的:所有使用這個(gè)內(nèi)存順序的操作都是在所有可能對(duì)其他線程都有可見副作用的內(nèi)存中執(zhí)行的。

* 這是最嚴(yán)格的內(nèi)存順序，在非原子內(nèi)存訪問(wèn)的情況下，保證了線程交互中最不意外的副作用。

* 對(duì)于消費(fèi)和獲取負(fù)載，順序一致的存儲(chǔ)操作被認(rèn)為是發(fā)布操作。

四、Functions

template

T kill_dependency (T y) noexcept;

* 返回y的值而不需要依賴項(xiàng)。

* 使用memory_order_consume 作為內(nèi)存順序的原子操作，要求編譯器檢查通過(guò)訪問(wèn)存儲(chǔ)的內(nèi)存位置所帶來(lái)的依賴關(guān)系。同步這樣的依賴關(guān)系可能會(huì)導(dǎo)致某些硬件設(shè)置被設(shè)置，并迫使編譯器放棄涉及這些內(nèi)存位置的某些潛在優(yōu)化。

* 調(diào)用此函數(shù)指示編譯器，任何依賴于y的依賴項(xiàng)都不應(yīng)被傳遞到返回值，而不需要同步。

extern "C" void atomic_thread_fence (memory_order sync) noexcept;

建立一個(gè)多線程的隔離:對(duì)這個(gè)函數(shù)的調(diào)用的時(shí)間點(diǎn)變成一個(gè)獲取或者一個(gè)釋放(或者兩者都是)的同步點(diǎn)。

在調(diào)用這個(gè)函數(shù)之前發(fā)生的釋放線程的所有可見的副作用都是同步的，在調(diào)用這個(gè)函數(shù)在獲取線程之前。

調(diào)用該函數(shù)與加載或存儲(chǔ)原子操作具有相同的效果，但不涉及原子值。

extern "C" void atomic_signal_fence (memory_order sync) noexcept;

建立一個(gè)單線程的隔離:對(duì)這個(gè)函數(shù)的調(diào)用點(diǎn)在一個(gè)線程內(nèi)變成一個(gè)獲取或一個(gè)釋放點(diǎn)(或者兩者)。

這個(gè)函數(shù)相當(dāng)于atomic_thread_fence ，但是沒(méi)有因?yàn)檎{(diào)用而發(fā)生線程間同步。該函數(shù)的作用是對(duì)編譯器進(jìn)行指令，以阻止它進(jìn)行優(yōu)化，包括將寫操作移動(dòng)到一個(gè)釋放柵欄或在獲取柵欄之前的讀操作。

五、 Functions for atomic objects (C-style)

template (1)

template bool atomic_is_lock_free (const volatile atomic* obj) noexcept;

template bool atomic_is_lock_free (const atomic* obj) noexcept;

overloads (2)

bool atomic_is_lock_free (const volatile A* obj) noexcept;

bool atomic_is_lock_free (const A* obj) noexcept;

是否是lock_free。

注意：

除了std::atomicflag的所有原子類型都可以使用互斥鎖或其他鎖定操作實(shí)現(xiàn)，而不是使用無(wú)鎖的原子CPU指令。原子類型也被允許有時(shí)是無(wú)鎖的，例如，如果在給定的體系結(jié)構(gòu)中，只有對(duì)齊的內(nèi)存訪問(wèn)是自然的，那么相同類型的不一致的對(duì)象就必須使用鎖。

C++標(biāo)準(zhǔn)推薦(但不需要)無(wú)鎖的原子操作也是無(wú)地址的，也就是說(shuō)，適合于使用共享內(nèi)存的進(jìn)程之間的通信。

示例15 (同示例3)：

#include

struct A { int a[100]; };

struct B { int x, y; };

int main()

{

std::atomic a;

std::atomic b;

std::cout << std::boolalpha

<< "std::atomic is lock free? "

<< std::atomic_is_lock_free(&a) << '\n'

<< "std::atomic is lock free? "

<< std::atomic_is_lock_free(&b) << '\n';

return 0;

}

template (1)

template void atomic_init (volatile atomic* obj, T val) noexcept;

template void atomic_init (atomic* obj, T val) noexcept;

overloads (2)

void atomic_init (volatile A* obj, T val) noexcept;

void atomic_init (A* obj, T val) noexcept;

用val的一個(gè)包含值初始化obj,該函數(shù)不是原子性的:來(lái)自另一個(gè)線程的并發(fā)訪問(wèn)，即使是通過(guò)原子操作，也是一種數(shù)據(jù)競(jìng)爭(zhēng)。

如果obj不是默認(rèn)構(gòu)造，那么這個(gè)行為就沒(méi)有定義。

如果這個(gè)函數(shù)在同一個(gè)obj上被調(diào)用兩次，那么這個(gè)行為是沒(méi)有定義的。

template (1)

template void atomic_store (volatile atomic* obj, T val) noexcept;

template void atomic_store (atomic* obj, T val) noexcept;

template

void atomic_store_explicit (volatile atomic* obj, T val, memory_order sync) noexcept;

template

void atomic_store_explicit (atomic* obj, T val, memory_order sync) noexcept;

overloads (2)

void atomic_store (volatile A* obj, T val) noexcept;

void atomic_store (A* obj, T val) noexcept;

void atomic_store_explicit (volatile A* obj, T val, memory_order sync) noexcept;

void atomic_store_explicit (A* obj, T val, memory_order sync) noexcept;

用val替換obj中包含的值。該操作是原子性的，atomic_store 使用順序一致性(memory_order_seq_cst), atomic_store_explicit 顯示制定內(nèi)存順序。參見stomic的等價(jià)函數(shù)atomic::store和 atomic::operator=。

template (1)

template T atomic_load (const volatile atomic* obj) noexcept;

template T atomic_load (const atomic* obj) noexcept;

template

T atomic_load_explicit (const volatile atomic* obj, memory_order sync) noexcept;

template

T atomic_load_explicit (const atomic* obj, memory_order sync) noexcept;

overloads (2)

T atomic_load (const volatile A* obj) noexcept;

T atomic_load (const A* obj) noexcept;

T atomic_load_explicit (const volatile A* obj, memory_order sync) noexcept;

T atomic_load_explicit (const A* obj, memory_order sync) noexcept;

同上面函數(shù)，返回obj中包含的值。該操作是原子性的，并使用順序一致性(memory_order_seq_cst)。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_load_explicit。

template (1)

template T atomic_exchange (volatile atomic* obj, T val) noexcept;

template T atomic_exchange (atomic* obj, T val) noexcept;

template

T atomic_exchange_explicit(volatile atomic* obj, T val, memory_order sync) noexcept;

template

T atomic_exchange_explicit(atomic* obj, T val, memory_order sync) noexcept;

overloads (2)

T atomic_exchange (volatile A* obj, T val) noexcept;

T atomic_exchange (A* obj, T val) noexcept;

T atomic_exchange_explicit(volatile A* obj, T val, memory_order sync) noexcept;

T atomic_exchange_explicit(A* obj, T val, memory_order sync) noexcept;

用val替換obj中包含的值，并返回obj之前的值。

整個(gè)操作是原子性的(一個(gè)原子的讀-修改-寫操作):在讀取(返回)值和被該函數(shù)修改的瞬間之間，obj的值不會(huì)受到其他線程的影響。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_exchange_explicit。

注意：這個(gè)顯示代碼網(wǎng)站上有錯(cuò)誤，本文已經(jīng)改正。

template (1)

template

bool atomic_compare_exchange_weak (volatile atomic* obj, T* expected, T val) noexcept;

template

bool atomic_compare_exchange_weak (atomic* obj, T* expected, T val) noexcept;

template

bool atomic_compare_exchange_weak_explicit (volatile atomic* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

template

bool atomic_compare_exchange_weak_explicit (atomic* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

overloads (2)

bool atomic_compare_exchange_weak (volatile A* obj, T* expected, T val) noexcept;

bool atomic_compare_exchange_weak (A* obj, T* expected, T val) noexcept;

bool atomic_compare_exchange_weak_explicit (volatile A* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

bool atomic_compare_exchange_weak_explicit (A* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

將obj中包含的值與預(yù)期的內(nèi)容進(jìn)行比較:

-如果是真的，它會(huì)用val替換包含的值。

-如果是假的，它將用所包含的值替換預(yù)期值

函數(shù)總是訪問(wèn)包含的值來(lái)讀取它，如果這個(gè)比較是真的，那么它也會(huì)替換它。但是整個(gè)操作都是原子性的:在讀取值和被替換的時(shí)刻之間，它的值不能被其他線程修改。

** 注意：

對(duì)于非循環(huán)算法來(lái)說(shuō)， compare_exchange_strong通常是首選。

template (1)

template

bool atomic_compare_exchange_strong (volatile atomic* obj, T* expected, T val) noexcept;

template

bool atomic_compare_exchange_strong (atomic* obj, T* expected, T val) noexcept;

template

bool atomic_compare_exchange_strong_explicit (volatile atomic* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

template

bool atomic_compare_exchange_strong_explicit (atomic* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

overloads (2)

bool atomic_compare_exchange_strong (volatile A* obj, T* expected, T val) noexcept;

bool atomic_compare_exchange_strong (A* obj, T* expected, T val) noexcept;

bool atomic_compare_exchange_strong_explicit (volatile A* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

bool atomic_compare_exchange_strong_explicit (A* obj,

T* expected, T val, memory_order success, memory_order failure) noexcept;

將obj中包含的值與預(yù)期的值進(jìn)行比較:

-如果是真的，它會(huì)用val替換包含的值。

-如果是假的，它將用所包含的值替換預(yù)期值。

** 注意：

compare_exchange_strong 跟 compare_exchange_week 不同的是：

template (integral) (1)

template T atomic_fetch_add (volatile atomic* obj, T val) noexcept;

template T atomic_fetch_add (atomic* obj, T val) noexcept;

template

T atomic_fetch_add_explicit (volatile atomic* obj, T val, memory_order sync) noexcept;

template

T atomic_fetch_add_explicit (atomic* obj, T val, memory_order sync) noexcept;

template (pointer) (2)

template U* atomic_fetch_add (volatile atomic* obj, ptrdiff_t val) noexcept;

template U* atomic_fetch_add (atomic* obj, ptrdiff_t val) noexcept;

template

U* atomic_fetch_add_explicit (volatile atomic* obj, ptrdiff_t val, memory_order sync) noexcept;

template

U* atomic_fetch_add_explicit (atomic* obj, ptrdiff_t val, memory_order sync) noexcept;

overloads (3)

T atomic_fetch_add (volatile A* obj, M val) noexcept;

T atomic_fetch_add (A* obj, M val) noexcept;

T atomic_fetch_add_explicit (volatile A* obj, M val, memory_order sync) noexcept;

T atomic_fetch_add_explicit (A* obj, M val, memory_order sync) noexcept;

將val添加到obj中所包含的值。整個(gè)操作都是原子性的:在讀取(返回)值和被該函數(shù)修改的時(shí)刻之間，值不能被修改。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_fetch_add_explicit 。

template (integral) (1)

template T atomic_fetch_sub (volatile atomic* obj, T val) noexcept;

template T atomic_fetch_sub (atomic* obj, T val) noexcept;

template

T atomic_fetch_sub_explicit (volatile atomic* obj, T val, memory_order sync) noexcept;

template

T atomic_fetch_sub_explicit (atomic* obj, T val, memory_order sync) noexcept;

template (pointer) (2)

template U* atomic_fetch_sub (volatile atomic* obj, ptrdiff_t val) noexcept;

template U* atomic_fetch_sub (atomic* obj, ptrdiff_t val) noexcept;

template

U* atomic_fetch_sub_explicit (volatile atomic* obj, ptrdiff_t val, memory_order sync) noexcept;

template

U* atomic_fetch_sub_explicit (atomic* obj, ptrdiff_t val, memory_order sync) noexcept;

overloads (3)

T atomic_fetch_sub (volatile A* obj, M val) noexcept;

T atomic_fetch_sub (A* obj, M val) noexcept;

T atomic_fetch_sub_explicit (volatile A* obj, M val, memory_order sync) noexcept;

T atomic_fetch_sub_explicit (A* obj, M val, memory_order sync) noexcept;

從obj中所包含的值減去val。整個(gè)操作都是原子性的:在讀取(返回)值和被該函數(shù)修改的時(shí)刻之間，值不能被修改。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_fetch_sub_explicit 。

template (integral) (1)

template T atomic_fetch_and (volatile atomic* obj, T val) noexcept;

template T atomic_fetch_and (atomic* obj, T val) noexcept;

template

T atomic_fetch_and_explicit (volatile atomic* obj,T val, memory_order sync) noexcept;

template

T atomic_fetch_and_explicit (atomic* obj,T val, memory_order sync) noexcept;

overloads (2)

T atomic_fetch_and (volatile A* obj, T val) noexcept;

T atomic_fetch_and (A* obj, T val) noexcept;

T atomic_fetch_and_explicit (volatile A* obj, T val, memory_order sync) noexcept;

T atomic_fetch_and_explicit (A* obj, T val, memory_order sync) noexcept;

讀取obj中包含的值，并通過(guò)在讀取值和val之間執(zhí)行一個(gè)位操作“與”操作來(lái)替換它。

整個(gè)操作是原子性的(一個(gè)原子的讀-修改-寫操作):在讀取(返回)值和被該函數(shù)修改的那一刻之間，值不會(huì)受到其他線程的影響。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_fetch_and_explicit 。

template (integral) (1)

template T atomic_fetch_or (volatile atomic* obj, T val) noexcept;

template T atomic_fetch_or (atomic* obj, T val) noexcept;

template

T atomic_fetch_or_explicit (volatile atomic* obj, T val, memory_order sync) noexcept;

template

T atomic_fetch_or_explicit (atomic* obj,T val, memory_order sync) noexcept;

overloads (2)

T atomic_fetch_or (volatile A* obj, T val) noexcept;

T atomic_fetch_or (A* obj, T val) noexcept;

T atomic_fetch_or_explicit (volatile A* obj, T val, memory_order sync) noexcept;

T atomic_fetch_or_explicit (A* obj, T val, memory_order sync) noexcept;

讀取obj中包含的值，并通過(guò)在讀取值和val之間執(zhí)行一個(gè)位操作“或”操作來(lái)替換它。

整個(gè)操作是原子性的(一個(gè)原子的讀-修改-寫操作):在讀取(返回)值和被該函數(shù)修改的那一刻之間，值不會(huì)受到其他線程的影響。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_fetch_or_explicit

template (integral) (1)

template T atomic_fetch_xor (volatile atomic* obj, T val) noexcept;

template T atomic_fetch_xor (atomic* obj, T val) noexcept;

template

T atomic_fetch_xor_explicit (volatile atomic* obj,T val, memory_order sync) noexcept;

template

T atomic_fetch_xor_explicit (atomic* obj,T val, memory_order sync) noexcept;

overloads (2)

T atomic_fetch_xor (volatile A* obj, T val) noexcept;

T atomic_fetch_xor (A* obj, T val) noexcept;

T atomic_fetch_xor_explicit (volatile A* obj, T val, memory_order sync) noexcept;

T atomic_fetch_xor_explicit (A* obj, T val, memory_order sync) noexcept;

讀取obj中包含的值，并通過(guò)在讀取值和val之間執(zhí)行一個(gè)位操作“異或”操作來(lái)替換它。

整個(gè)操作是原子性的(一個(gè)原子的讀-修改-寫操作):在讀取(返回)值和被該函數(shù)修改的那一刻之間，值不會(huì)受到其他線程的影響。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_fetch_xor_explicit

bool atomic_flag_test_and_set (volatile atomic_flag* obj) noexcept;

bool atomic_flag_test_and_set (atomic_flag* obj) noexcept;

bool atomic_flag_test_and_set (volatile atomic_flag* obj, memory_order sync) noexcept;

bool atomic_flag_test_and_set (atomic_flag* obj, memory_order sync) noexcept;

設(shè)置obj指向的原子標(biāo)志，并返回調(diào)用之前的值。

整個(gè)操作是原子性的(一個(gè)原子的讀-修改-寫操作):在讀取(返回)值和被該函數(shù)修改的瞬間之間，obj的值不會(huì)受到其他線程的影響。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_flag_test_and_set

void atomic_flag_clear (volatile atomic_flag* obj) noexcept;

void atomic_flag_clear (atomic_flag* obj) noexcept;

void atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order sync) noexcept;

void atomic_flag_clear_explicit(atomic_flag* obj, memory_order sync) noexcept;

清除obj，將它的標(biāo)志值設(shè)置為false。該操作是原子性的。要制定內(nèi)存數(shù)序使用顯示調(diào)用函數(shù)atomic_flag_clear_explicit。

六、Macro functions

ATOMIC_VAR_INIT

ATOMIC_VAR_INIT(val) //初始化 std::atomic 對(duì)象。

這個(gè)宏的存在是為了與C實(shí)現(xiàn)兼容，在其中，它被用作構(gòu)造函數(shù)(默認(rèn)構(gòu)造的)原子對(duì)象;在C++中，這個(gè)初始化可以由初始化構(gòu)造函數(shù)直接執(zhí)行。

ATOMIC_FLAG_INIT

ATOMIC_FLAG_INIT //初始化 std::atomic_flag 對(duì)象。

這個(gè)宏的定義用來(lái)將類型std::atomic_flag的對(duì)象初始化到clear的狀態(tài)。

總結(jié)

以上是生活随笔為你收集整理的atomic头文件编译_c++11 多线程（3）atomic 总结的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。