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

最新推荐文章于 2023-10-05 01:18:54 发布

langb2014

最新推荐文章于 2023-10-05 01:18:54 发布

阅读量1.4k

点赞数

分类专栏： C++(Boost)

本文链接：https://blog.csdn.net/langb2014/article/details/50522023

版权

C++(Boost) 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

`<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;//隐式类型转换，相当于load
	T 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();
}

运行结果：