Boost源码学习十一[并发编程]（2）

时间：2022-11-10 18:02:06

<atomic> 头文件摘要

1std::atomic_flag 类摘要

namespace std {
    typedef struct atomic_flag {
        bool test_and_set(memory_order = memory_order_seq_cst) volatile;
        bool test_and_set(memory_order = memory_order_seq_cst);

        void clear(memory_order = memory_order_seq_cst) volatile;
        void clear(memory_order = memory_order_seq_cst);

        atomic_flag() = default;
        atomic_flag(const atomic_flag&) = delete;

        atomic_flag& operator=(const atomic_flag&) = delete;
        atomic_flag& operator=(const atomic_flag&) volatile = delete;
    } atomic_flag;

    bool atomic_flag_test_and_set(volatile atomic_flag*);
    bool atomic_flag_test_and_set(atomic_flag*);

    bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);
    bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);

    void atomic_flag_clear(volatile atomic_flag*);
    void atomic_flag_clear(atomic_flag*);

    void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);
    void atomic_flag_clear_explicit(atomic_flag*, memory_order);

    #define ATOMIC_FLAG_INIT see below
}

2 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);
};

3 std::atomic 整型特化摘要

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);
};

4 std::atomic 指针特化摘要

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);
};
下面是boost的atomic库的类摘要：
template<typename T>class atomic:public atomics::detail::base_atomic<T>{public:atomic() = default;//缺省构造explicit atomic(T v);//指定初始值构造atomic(atomic const&) = delete;//禁止对象间拷贝atomic& operator=atomic(atomic const&) = delete;//禁止对象间赋值bool is_lock_free();//是否无锁void store(T value);//存值T load();//取值T operator=(T v)volatile;//赋值operator T() volatile const;//隐式类型转换，相当于loadT exchange(T new_value);//存值，同时返回原值bool compare_exchange_weak(T &expected,T desired);//bool compare_exchange_strong(T &expected, T desired);//T & storage();//获取内部值T const& storage() const;//};
用法：
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
using namespace std;

#include <boost/atomic.hpp>
using namespace boost;

//////////////////////////////////////////
void case1()
{
atomic<int> a(10);
assert(a == 10);

atomic<long> l;
l = 100L;
cout << l << endl;

atomic<double> d(2.414);
cout << d << endl;
}

//////////////////////////////////////////
void case2()
{
atomic<bool> b{ false };
assert(!b.load());

b.store(true);
assert(b);

atomic<int> n(100);
assert(n.exchange(200) == 100);
assert(n == 200);
}
//////////////////////////////////////////
void case3()
{
atomic<long> l(100);

long v = 100;
if (l.compare_exchange_weak(v, 313))
{
assert(l == 313 && v == 100);
}

v = 200;
auto b = l.compare_exchange_strong(v, 99);
assert(!b && v == 313);

l.compare_exchange_weak(v, 99);
assert(l == 99 && v == 313);
}

//////////////////////////////////////////
#include <boost/utility.hpp>
void case4()
{
atomic<int> n(100);

assert(n.fetch_add(10) == 100);
assert(n == 110);

assert(++n == 111);
assert(n++ == 111);
assert(n == 112);

assert((n -= 10) == 102);

atomic<int> b{ BOOST_BINARY(1101) };

auto x = b.fetch_and(BOOST_BINARY(0110));
assert(x == BOOST_BINARY(1101) &&
b == BOOST_BINARY(0100));
assert((b |= BOOST_BINARY(1001))
== BOOST_BINARY(1101));
}

//////////////////////////////////////////
void case5()
{
atomic<bool> b{ true };
assert(b);

b = false;
assert(!b.load());

auto x = b.exchange(true);
assert(b && !x);
}
int main()
{
case1();
case2();
case3();
case4();
case5();
}

运行结果：
100 
2.414

标签：

相关文章