C++11 并发指南六( 类型详解二 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 {
     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 {
     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        // std::cout
#include          // std::atomic, std::atomic_flag, ATOMIC_FLAG_INIT
#include          // std::thread, std::this_thread::yield
#include          // std::vector
 
// 由 false 初始化一个 std::atomic 类型的原子变量
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 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              // std::cout
#include                // std::atomic
#include                // 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 类型所具备的操作:

bool  is_lock_free() const  volatile  noexcept ;
bool  is_lock_free() const  noexcept ;
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 ;
Memory Order 值 Memory Order 类型
memory_order_relaxed Relaxed
memory_order_release Release
memory_order_seq_cst Sequentially consistent
#include        // std::cout
#include          // std::atomic, std::memory_order_relaxed
#include          // 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;
}
T load (memory_order sync = memory_order_seq_cst) const  volatile  noexcept ;
T load (memory_order sync = memory_order_seq_cst) const  noexcept ;
Memory Order 值 Memory Order 类型
memory_order_relaxed Relaxed
memory_order_consume Consume
memory_order_acquire Acquire
memory_order_seq_cst Sequentially consistent
#include        // std::cout
#include          // std::atomic, std::memory_order_relaxed
#include          // 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() const  volatile  noexcept ;
operator T() const  noexcept ;
#include        // std::cout
#include          // std::atomic
#include          // 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;
}

 

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;
Memory Order 值 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

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

#include        // std::cout
#include          // std::atomic
#include          // std::thread
#include          // 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 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;
}
(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;
  • 相等,则用 val 替换原子对象的旧值。
  • 不相等,则用原子对象的旧值替换 expected ,因此调用该函数之后,如果被该原子对象封装的值与参数 expected 所指定的值不相等,expected 中的内容就是原子对象的旧值。
Memory Order 值 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
#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* 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 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

 

(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;
  • 相等,则用 val 替换原子对象的旧值。
  • 不相等,则用原子对象的旧值替换 expected ,因此调用该函数之后,如果被该原子对象封装的值与参数 expected 所指定的值不相等,expected 中的内容就是原子对象的旧值。
Memory Order 值 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
#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* 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 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)和指针类型的特化版本做了哪些改进。

你可能感兴趣的