C++11 并发指南六( <atomic> 类型详解二 std::atomic )

最新推荐文章于 2023-01-29 11:48:07 发布
最新推荐文章于 2023-01-29 11:48:07 发布
阅读量465 收藏
点赞数
分类专栏： C/C++ 文章标签： C++11 atomic


C++11 并发指南六(atomic 类型详解一 atomic_flag 介绍)  一文介绍了 C++11 中最简单的原子类型 std::atomic_flag，但是 std::atomic_flag 过于简单，只提供了 test_and_set 和 clear 两个 API，不能满足其他需求(如 store, load, exchange, compare_exchange 等)，因此本文将介绍功能更加完善的 std::atomic 类。

std::atomic 基本介绍

std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。

template <class T> struct atomic;

原子类型对象的主要特点就是从不同线程访问不会导致数据竞争(data race)。因此从不同线程访问某个原子对象是良性 (well-defined) 行为，而通常对于非原子类型而言，并发访问某个对象（如果不做任何同步操作）会导致未定义 (undifined) 行为发生。

C++11 标准中的基本 std::atomic 模板定义如下：

复制代码 
template < class T > struct atomic {
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(T, memory_order = memory_order_seq_cst) volatile;
    void store(T, memory_order = memory_order_seq_cst);
    T load(memory_order = memory_order_seq_cst) const volatile;
    T load(memory_order = memory_order_seq_cst) const;
    operator  T() const volatile;
    operator  T() const;
    T exchange(T, memory_order = memory_order_seq_cst) volatile;
    T exchange(T, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(T &, T, memory_order, memory_order) volatile;
    bool compare_exchange_weak(T &, T, memory_order, memory_order);
    bool compare_exchange_strong(T &, T, memory_order, memory_order) volatile;
    bool compare_exchange_strong(T &, T, memory_order, memory_order);
    bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(T &, T, memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(T &, T, memory_order = memory_order_seq_cst);
    atomic() = default;
    constexpr atomic(T);
    atomic(const atomic &) = delete;
    atomic & operator=(const atomic &) = delete;
    atomic & operator=(const atomic &) volatile = delete;
    T operator=(T) volatile;
    T operator=(T);
};
复制代码

另外，C++11 标准库 std::atomic 提供了针对整形(integral)和指针类型的特化实现，分别定义如下：

针对整形(integal)的特化，其中 integal 代表了如下类型char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, char16_t, char32_t, wchar_t：

?
template <> struct atomic<integral> {
     bool is_lock_free() const volatile ;
     bool is_lock_free() const ;
 
     void store(integral, memory_order = memory_order_seq_cst) volatile ;
     void store(integral, memory_order = memory_order_seq_cst);
 
     integral load(memory_order = memory_order_seq_cst) const volatile ;
     integral load(memory_order = memory_order_seq_cst) const ;
 
     operator integral() const volatile ;
     operator integral() const ;
 
     integral exchange(integral, memory_order = memory_order_seq_cst) volatile ;
     integral exchange(integral, memory_order = memory_order_seq_cst);
 
     bool compare_exchange_weak(integral&, integral, memory_order, memory_order) volatile ;
     bool compare_exchange_weak(integral&, integral, memory_order, memory_order);
 
     bool compare_exchange_strong(integral&, integral, memory_order, memory_order) volatile ;
     bool compare_exchange_strong(integral&, integral, memory_order, memory_order);
 
     bool compare_exchange_weak(integral&, integral, memory_order = memory_order_seq_cst) volatile ;
     bool compare_exchange_weak(integral&, integral, memory_order = memory_order_seq_cst);
 
     bool compare_exchange_strong(integral&, integral, memory_order = memory_order_seq_cst) volatile ;
     bool compare_exchange_strong(integral&, integral, memory_order = memory_order_seq_cst);
 
     integral fetch_add(integral, memory_order = memory_order_seq_cst) volatile ;
     integral fetch_add(integral, memory_order = memory_order_seq_cst);
 
     integral fetch_sub(integral, memory_order = memory_order_seq_cst) volatile ;
     integral fetch_sub(integral, memory_order = memory_order_seq_cst);
 
     integral fetch_and(integral, memory_order = memory_order_seq_cst) volatile ;
     integral fetch_and(integral, memory_order = memory_order_seq_cst);
 
     integral fetch_or(integral, memory_order = memory_order_seq_cst) volatile ;
     integral fetch_or(integral, memory_order = memory_order_seq_cst);
 
     integral fetch_xor(integral, memory_order = memory_order_seq_cst) volatile ;
     integral fetch_xor(integral, memory_order = memory_order_seq_cst);
     
     atomic() = default ;
     constexpr atomic(integral);
     atomic( const atomic&) = delete ;
 
     atomic& operator=( const atomic&) = delete ;
     atomic& operator=( const atomic&) volatile = delete ;
     
     integral operator=(integral) volatile ;
     integral operator=(integral);
     
     integral operator++( int ) volatile ;
     integral operator++( int );
     integral operator--( int ) volatile ;
     integral operator--( int );
     integral operator++() volatile ;
     integral operator++();
     integral operator--() volatile ;
     integral operator--();
     integral operator+=(integral) volatile ;
     integral operator+=(integral);
     integral operator-=(integral) volatile ;
     integral operator-=(integral);
     integral operator&=(integral) volatile ;
     integral operator&=(integral);
     integral operator|=(integral) volatile ;
     integral operator|=(integral);
     integral operator^=(integral) volatile ;
     integral operator^=(integral);
};

针对指针的特化：

?
template < class T> struct atomic<T*> {
     bool is_lock_free() const volatile ;
     bool is_lock_free() const ;
 
     void store(T*, memory_order = memory_order_seq_cst) volatile ;
     void store(T*, memory_order = memory_order_seq_cst);
 
     T* load(memory_order = memory_order_seq_cst) const volatile ;
     T* load(memory_order = memory_order_seq_cst) const ;
 
     operator T*() const volatile ;
     operator T*() const ;
 
     T* exchange(T*, memory_order = memory_order_seq_cst) volatile ;
     T* exchange(T*, memory_order = memory_order_seq_cst);
 
     bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile ;
     bool compare_exchange_weak(T*&, T*, memory_order, memory_order);
 
     bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile ;
     bool compare_exchange_strong(T*&, T*, memory_order, memory_order);
 
     bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) volatile ;
     bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst);
 
     bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) volatile ;
     bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst);
 
     T* fetch_add( ptrdiff_t , memory_order = memory_order_seq_cst) volatile ;
     T* fetch_add( ptrdiff_t , memory_order = memory_order_seq_cst);
 
     T* fetch_sub( ptrdiff_t , memory_order = memory_order_seq_cst) volatile ;
     T* fetch_sub( ptrdiff_t , memory_order = memory_order_seq_cst);
 
     atomic() = default ;
     constexpr atomic(T*);
     atomic( const atomic&) = delete ;
 
     atomic& operator=( const atomic&) = delete ;
     atomic& operator=( const atomic&) volatile = delete ;
 
     T* operator=(T*) volatile ;
     T* operator=(T*);
     T* operator++( int ) volatile ;
     T* operator++( int );
     T* operator--( int ) volatile ;
     T* operator--( int );
     T* operator++() volatile ;
     T* operator++();
     T* operator--() volatile ;
     T* operator--();
     T* operator+=( ptrdiff_t ) volatile ;
     T* operator+=( ptrdiff_t );
     T* operator-=( ptrdiff_t ) volatile ;
     T* operator-=( ptrdiff_t );
};

std::atomic 成员函数

 好了，对 std::atomic 有了一个最基本认识之后我们来看 std::atomic 的成员函数吧。

std::atomic 构造函数

std::atomic 的构造函数如下：

default (1) 
          atomic() noexcept = default;
initialization (2) 
constexpr atomic (T val) noexcept;
copy [deleted] (3) 
          atomic (const atomic&) = delete;
  1. 默认构造函数，由默认构造函数创建的 std::atomic 对象处于未初始化(uninitialized)状态，对处于未初始化(uninitialized)状态 std::atomic对象可以由 atomic_init 函数进行初始化。
  2. 初始化构造函数，由类型 T初始化一个 std::atomic对象。
  3. 拷贝构造函数被禁用。

请看下例：

?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT
#include <thread>         // std::thread, std::this_thread::yield
#include <vector>         // std::vector
 
// 由 false 初始化一个 std::atomic<bool> 类型的原子变量
std::atomic< bool > ready( false );
std::atomic_flag winner = ATOMIC_FLAG_INIT;
 
void do_count1m( int id)
{
     while (!ready) { std::this_thread::yield(); } // 等待 ready 变为 true.
 
     for ( volatile int i=0; i<1000000; ++i) {} // 计数
 
     if (!winner.test_and_set()) {
       std::cout << "thread #" << id << " won!\n" ;
     }
}
 
int main ()
{
     std::vector<std:: 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;
}
std::atomic::operator=() 函数

std::atomic 的赋值操作函数定义如下：

set value (1) 
T operator= (T val) noexcept;
T operator= (T val) volatile noexcept;
copy [deleted] (2) 
atomic& operator= (const atomic&) = delete;
atomic& operator= (const atomic&) volatile = delete;

可以看出，普通的赋值拷贝操作已经被禁用。但是一个类型为 T 的变量可以赋值给相应的原子类型变量（相当与隐式转换），该操作是原子的，内存序(Memory Order) 默认为顺序一致性(std::memory_order_seq_cst)，如果需要指定其他的内存序，需使用 std::atomic::store()。

?
#include <iostream>             // std::cout
#include <atomic>               // std::atomic
#include <thread>               // std::thread, std::this_thread::yield
 
std::atomic < int > foo = 0;
 
void set_foo( int x)
{
     foo = x; // 调用 std::atomic::operator=().
}
 
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;
}
基本 std::atomic 类型操作

本节主要介绍基本 std::atomic 类型所具备的操作（即成员函数）。我们知道 std::atomic 是模板类，一个模板类型为 T 的原子对象中封装了一个类型为 T 的值。本文<std::atomic 基本介绍>一节中也提到了 std::atomic 类模板除了基本类型以外，还针对整形和指针类型做了特化。 特化的 std::atomic 类型支持更多的操作，如 fetch_add, fetch_sub, fetch_and 等。本小节介绍基本 std::atomic 类型所具备的操作：

is_lock_free
?
bool is_lock_free() const volatile noexcept ;
bool is_lock_free() const noexcept ;
判断该 std::atomic 对象是否具备 lock-free 的特性。如果某个对象满足 lock-free 特性，在多个线程访问该对象时不会导致线程阻塞。(可能使用某种事务内存 transactional memory方法实现 lock-free 的特性)。
store
?
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 ;
修改被封装的值，std::atomic::store 函数将类型为 T 的参数 val 复制给原子对象所封装的值。T 是 std::atomic 类模板参数。另外参数 sync 指定内存序(Memory Order)，可能的取值如下：
Memory Order 值Memory Order 类型
memory_order_relaxedRelaxed
memory_order_releaseRelease
memory_order_seq_cstSequentially consistent
请看下面例子：
?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread
 
std::atomic< int > foo(0); // 全局的原子对象 foo
 
void set_foo( int x)
{
     foo.store(x, std::memory_order_relaxed); // 设置(store) 原子对象 foo 的值
}
 
void print_foo()
{
     int x;
     do {
         x = foo.load(std::memory_order_relaxed); // 读取(load) 原子对象 foo 的值
     } while (x == 0);
     std::cout << "foo: " << x << '\n' ;
}
 
int main ()
{
     std:: thread first(print_foo); // 线程 first 打印 foo 的值
     std:: thread second(set_foo, 10); // 线程 second 设置 foo 的值
     first.join();
     second.join();
     return 0;
}
load
?
T load (memory_order sync = memory_order_seq_cst) const volatile noexcept ;
T load (memory_order sync = memory_order_seq_cst) const noexcept ;
读取被封装的值，参数 sync 设置内存序(Memory Order)，可能的取值如下：
Memory Order 值Memory Order 类型
memory_order_relaxedRelaxed
memory_order_consumeConsume
memory_order_acquireAcquire
memory_order_seq_cstSequentially consistent
请看下面例子：
?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread
 
std::atomic< int > foo(0); // 全局的原子对象 foo
 
void set_foo( int x)
{
     foo.store(x, std::memory_order_relaxed); // 设置(store) 原子对象 foo 的值
}
 
void print_foo()
{
     int x;
     do {
         x = foo.load(std::memory_order_relaxed); // 读取(load) 原子对象 foo 的值
     } while (x == 0);
     std::cout << "foo: " << x << '\n' ;
}
 
int main ()
{
     std:: thread first(print_foo); // 线程 first 打印 foo 的值
     std:: thread second(set_foo, 10); // 线程 second 设置 foo 的值
     first.join();
     second.join();
     return 0;
}
operator T
?
operator T() const volatile noexcept ;
operator T() const noexcept ;
与 load 功能类似，也是 读取被封装的值，operator T() 是类型转换( type-cast) 操作，默认的内存序是 std::memory_order_seq_cst，如果需要指定其他的内存序，你应该使用 load() 函数。请看下面例子：
?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread, std::this_thread::yield
 
std::atomic< int > foo = 0;
std::atomic< int > bar = 0;
 
void set_foo( int x)
{
     foo = x;
}
 
void copy_foo_to_bar()
{
 
     // 如果 foo == 0，则该线程 yield,
     // 在 foo == 0 时, 实际也是隐含了类型转换操作,
     // 因此也包含了 operator T() const 的调用.
     while (foo == 0) std::this_thread::yield();
 
     // 实际调用了 operator T() const, 将foo 强制转换成 int 类型,
     // 然后调用 operator=().
     bar = static_cast < int >(foo);
}
 
void print_bar()
{
     // 如果 bar == 0，则该线程 yield,
     // 在 bar == 0 时, 实际也是隐含了类型转换操作,
     // 因此也包含了 operator T() const 的调用.
     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;
}

 

exchange 
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;
读取并修改被封装的值，exchange 会将 val 指定的值替换掉之前该原子对象封装的值，并返回之前该原子对象封装的值，整个过程是原子的(因此exchange 操作也称为 read-modify-write 操作)。sync参数指定内存序(Memory Order)，可能的取值如下：
Memory Order 值Memory Order 类型
memory_order_relaxedRelaxed
memory_order_consumeConsume
memory_order_acquireAcquire
memory_order_releaseRelease
memory_order_acq_relAcquire/Release
memory_order_seq_cstSequentially consistent

请看下面例子，各个线程计数至 1M，首先完成计数任务的线程打印自己的 ID，

?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector
 
std::atomic< bool > ready( false );
std::atomic< bool > 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<std:: 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;
}
compare_exchange_weak
(1) 
bool compare_exchange_weak (T& expected, T val,
           memory_order sync = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_weak (T& expected, T val,
           memory_order sync = memory_order_seq_cst) noexcept;
(2) 
bool compare_exchange_weak (T& expected, T val,
           memory_order success, memory_order failure) volatile noexcept;
bool compare_exchange_weak (T& expected, T val,
           memory_order success, memory_order failure) noexcept;
比较并交换被封装的值(weak)与参数  expected 所指定的值是否相等，如果：
  • 相等，则用 val 替换原子对象的旧值。
  • 不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。
该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于 expected)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。

在第 (2)种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于 expected)，则选择参数 success 指定的内存序，否则选择参数 failure 所指定的内存序。
注意，该函数直接比较原子对象所封装的值与参数 expected 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare_exchange_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。
与 compare_exchange_strong 不同, weak 版本的 compare-and-exchange 操作允许( spuriously 地)返回 false(即原子对象所封装的值与参数 expected 的物理内容相同，但却仍然返回 false)，不过在某些需要循环操作的算法下这是可以接受的，并且在一些平台下 compare_exchange_weak 的性能更好 。如果 compare_exchange_weak 的判断确实发生了伪失败( spurious failures)——即使原子对象所封装的值与参数 expected 的物理内容相同，但判断操作的结果却为 false，compare_exchange_weak函数返回 false，并且参数 expected 的值不会改变。
对于某些不需要采用循环操作的算法而言, 通常采用 compare_exchange_strong 更好。另外，该函数的内存序由  sync 参数指定，可选条件如下：
Memory Order 值Memory Order 类型
memory_order_relaxedRelaxed
memory_order_consumeConsume
memory_order_acquireAcquire
memory_order_releaseRelease
memory_order_acq_relAcquire/Release
memory_order_seq_cstSequentially consistent
请看下面的例子（ 参考）：
?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector
 
// a simple global linked list:
struct Node { int value; Node* next; };
std::atomic<Node*> list_head( nullptr );
 
void append( int val)
{
     // append an element to the list
     Node* newNode = new Node{val, list_head};
 
     // next is the same as: list_head = newNode, but in a thread-safe way:
     while (!list_head.compare_exchange_weak(newNode->next,newNode)) {}
     // (with newNode->next updated accordingly if some other thread just appended another node)
}
 
int main ()
{
     // spawn 10 threads to fill the linked list:
     std::vector<std:: 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;
}
可能的执行结果如下：
?
9 8 7 6 5 4 3 2 1 0

 

compare_exchange_strong
(1) 
bool compare_exchange_strong (T& expected, T val,
           memory_order sync = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_strong (T& expected, T val,
           memory_order sync = memory_order_seq_cst) noexcept;
(2) 
bool compare_exchange_strong (T& expected, T val,
           memory_order success, memory_order failure) volatile noexcept;
bool compare_exchange_strong (T& expected, T val,
           memory_order success, memory_order failure) noexcept;
比较并交换被封装的值(strong)与参数  expected 所指定的值是否相等，如果：
  • 相等，则用 val 替换原子对象的旧值。
  • 不相等，则用原子对象的旧值替换 expected ，因此调用该函数之后，如果被该原子对象封装的值与参数 expected 所指定的值不相等，expected 中的内容就是原子对象的旧值。
该函数通常会读取原子对象封装的值，如果比较为 true(即原子对象的值等于 expected)，则替换原子对象的旧值，但整个操作是原子的，在某个线程读取和修改该原子对象时，另外的线程不能对读取和修改该原子对象。

在第 (2)种情况下，内存序（Memory Order）的选择取决于比较操作结果，如果比较结果为 true(即原子对象的值等于 expected)，则选择参数 success 指定的内存序，否则选择参数 failure 所指定的内存序。
注意，该函数直接比较原子对象所封装的值与参数 expected 的物理内容，所以某些情况下，对象的比较操作在使用 operator==() 判断时相等，但 compare_exchange_weak 判断时却可能失败，因为对象底层的物理内容中可能存在位对齐或其他逻辑表示相同但是物理表示不同的值(比如 true 和 2 或 3，它们在逻辑上都表示"真"，但在物理上两者的表示并不相同)。
与 compare_exchange_weak 不同, strong版本的 compare-and-exchange 操作不允许( spuriously 地)返回 false，即原子对象所封装的值与参数 expected 的物理内容相同，比较操作一定会为 true。不过在某些平台下，如果算法本身需要循环操作来做检查， compare_exchange_weak 的性能会更好。
因此对于某些不需要采用循环操作的算法而言, 通常采用 compare_exchange_strong 更好。另外，该函数的内存序由  sync 参数指定，可选条件如下：
Memory Order 值Memory Order 类型
memory_order_relaxedRelaxed
memory_order_consumeConsume
memory_order_acquireAcquire
memory_order_releaseRelease
memory_order_acq_relAcquire/Release
memory_order_seq_cstSequentially consistent
请看下面的例子：
?
#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector
 
// a simple global linked list:
struct Node { int value; Node* next; };
std::atomic<Node*> list_head( nullptr );
 
void append( int val)
{
     // append an element to the list
     Node* newNode = new Node{val, list_head};
 
     // next is the same as: list_head = newNode, but in a thread-safe way:
 
     while (!(list_head.compare_exchange_strong(newNode->next, newNode)));
     // (with newNode->next updated accordingly if some other thread just appended another node)
}
 
int main ()
{
     // spawn 10 threads to fill the linked list:
     std::vector<std:: 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;
}


好了，本文花了大量的篇幅介绍 std::atomic 基本类型，下一篇博客我会给大家介绍 C++11 的标准库中std::atomic 针对整形(integral)和指针类型的特化版本做了哪些改进。

转自：http://www.cnblogs.com/haippy/archive/2013/09/05/3301408.html


_浪潮之巅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11并发编程关于原子操作atomic的代码示例
08-26
今天小编就为大家分享一篇关于C++11并发编程关于原子操作atomic的代码示例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C++11 并发指南六(atomic 类型详解三 std::atomic (续))
weixin_34220623的博客
09-06 326
C++11 并发指南六( &lt;atomic&gt; 类型详解二 std::atomic ) 介绍了基本的原子类型 std::atomic 的用法，本节我会给大家介绍C++11 标准库中的 std::atomic 针对整形(integral)和指针类型的特化版本做了哪些改进。 总地来说，C++11 标准库中的 std::atomic 针对整形(integral)和指针类型的特化版本新增了一些算...
C++11并发与多线程笔记（11） std::atomic续谈、std::async深入谈
qq_38231713的博客
05-13 2468
第十一节 std::atomic续谈、std::async深入谈 一、std::atomic续谈 #include <iostream> #include <thread> #include <atomic> using namespace std; std::atomic<int> g_count = 0; //封装了一个类型为int的 对象（值） void mythread1() { for (int i = 0; i < 1000000;
C++11并发编程：原子操作atomic
码农code之路
12-14 4632
一：概述 　　项目中经常用遇到多线程操作共享数据问题，常用的处理方式是对共享数据进行加锁，如果多线程操作共享变量也同样采用这种方式。 　　为什么要对共享变量加锁或使用原子操作？如两个线程操作同一变量过程中，一个线程执行过程中可能被内核临时挂起，这就是线程切换，当内核再次切换到该线程时，之前的数据可能已被修改，不能保证原子操作。 　　C++11提供了个原子的类和方法atomic，保证了多线程对...
atomic_queue：C ++无锁队列
01-28
atomic_queue 基于带有循环缓冲区的C ++ 14多生产者多消费者无锁队列。 这些队列遵循的主要设计原理是极简主义：原子操作的最基本要求，固定大小的缓冲区，值语义。 这些品质也有局限性： 最大队列大小必须在编译...
3、并发编程之CAS&Atomic原子操作详解.pdf
02-28
3、并发编程之CAS&Atomic原子操作详解
queue_atomic:使用C ++ 11原子的多生产者多消费者队列模板
04-27
queue_atomic 使用C ++ 11原子的多生产者多消费者队列模板。 通过将单调递增的版本号打包到队列的前后偏移量中，解决了ABA问题并实现了两阶段有序更新。 通过检查预期的版本计数器在打包的前后偏移量中是否可见来...
透析C语言可变参数问题
唯有前进值得敬仰
07-12 772
<br />一、是什么<br />我们学习C语言时最经常使用printf()函数，但我们很少了解其原型。其实printf()的参数就是可变参数，想想看，我们可以利用它打印出各种类型的数据。下面我们来看看它的原型：<br />int printf( const char* format, ...);<br />它的第一个参数是format，属于固定参数,后面跟的参数的个数和类型都是可变的（用三个点“…”做参数占位符）,实际调用时可以有以下的形式: <br />printf("%d",i); <br />pri
C++ 原子操作 std::atomic<T>
TuxedoLinux的博客
01-17 1084
C++ 原子操作 std::atomic&lt;T&gt; std::atomic&lt;T&gt;模板类可以使对象操作为原子操作，避免多线程竞争问题；请看如下代码，一目了然： class Test { public: Test() = default; void CThreadFunc() { for (int i = 0; i &lt...
C++ 多线程：原子类型(stdatomic)
这是一个c++热爱者的博客哟
01-24 2904
atomic类型原子操作宣告C++11来到了多线程和并行编程的时代。相对于偏于底层的pthread库，C++通过定义原子类型的方式，轻松地化解了互斥访问共享数据的难题。不过C++也延续了其易于学习难于精通的特性，虽然atomic原子类型使用上较为简单，但其函数接口(原子操作)却可以有不用的内存顺序。C++11从各种不同的平台上抽象出了一个软件的内存模型，并以内存顺序进行描述，以使得想进一步挖掘并行系统性能的程序员有足够简单的手段来完成以往只能通过内联汇编来完成的工作。本文介绍的和。
《C++ Concurrency in Action》笔记23 std::atomic<bool>
t114211200的博客
09-28 4066
5.2.3 std::atomic的相关操作 最基本的内置类型就是std::atomic，这是个比atomic_flag更为全面的bool量。尽管它仍然不支持拷贝构造和拷贝赋值，但是它可以从一个非原子类型的bool量构造，也可以用一个非原子类型来给std::atomic赋值： std::atomic b(true); b=false; 需要注意的是，复制操作并不像我们平时那样返回对象引用，而
C++11 并发指南六( 类型详解二 stdatomic )
这是一个c++热爱者的博客哟
01-28 3997
一节中也提到了 std::atomic 类模板除了基本类型以外，还针对整形和指针类型做了特化。特化的 std::atomic 类型支持更多的操作，如 fetch_add, fetch_sub, fetch_and 等。
C++11 并发指南六(atomic 类型详解三 stdatomic (续))
这是一个c++热爱者的博客哟
01-29 3852
C++11 并发指南六( 类型详解二 std::atomic ) 介绍了基本的原子类型 std::atomic 的用法，本节我会给大家介绍C++11 标准库中的 std::atomic 针对整形(integral)和指针类型的特化版本做了哪些改进。
原子操作 std::atomic＜int＞
rukawashan的博客
06-06 984
std::atomic模板类可以使对象操作为原子操作，避免多线程竞争问题；请看如下代码，一目了然class Test { public: Test() = default; void CThreadFunc() { for (int i = 0; i < 10000; ++i) { //std::lock_guard lck(Test::m_s_ivalue_mutex); //m_iV...
node-v6.3.1-linux-ppc64.tar.xz
最新发布
05-10
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
计算机专业词汇+英语+计算机能不学英语吗？
05-10
计算机专业英语词汇非常丰富，涉及计算机硬件、软件、网络、程序设计语言等多个方面。由于篇幅限制，我无法直接列出完整的1000个计算机专业英语词汇，但我可以为您提供一些常见的计算机专业英语词汇作为示例： file - 文件 command - 命令，指令 use - 使用，用途 program - 程序 line - (数据，程序)行，线路 if - 如果（连词） display - 显示，显示器 set - 设置（动词），集合（名词） key - 键，关键字，关键码 list - 列表，显示（名词），打印（动词） by - 凭，靠，沿（介词） press - 按，压（动词） with - 用，与，随着（介词） format - 格式 change - 更换，改变，变动（动词）
35-35.渗透测试SQL注入之SQL注入防御
05-10
35-35.渗透测试SQL注入之SQL注入防御
std::queue<int> taskQueue;改成std::atomic
05-31
如果要将 `std::queue<int> taskQueue` 改成 `std::atomic<std::queue<int>> taskQueue`，需要注意以下几点： 1. `std::queue` 并不是一个原子类型，因此不能直接使用原子类型来包装它。 2. 可以将 `std::queue` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值