Boost Source Learning 11 [Concurrent programming] (2) __ Programming

Source: Internet
Author: User
<atomic> Header File Summary 1std::atomic_flag Class Summary
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 below}
2 std::atomic Basic Type Summary
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 integer-specific summary
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 Pointer Special summary
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); };
The following is a summary of the class for boost's atomic library:
Template<typename t>
class Atomic:public Atomics::d etail::base_atomic<t>
{public
:
	Atomic () = default;//default construct
	explicit atomic (T v);//Specify initial value construct
	atomic (atomic const&) = delete;//prohibit copying
	between objects atomic& operator=atomic (atomic const&) = delete;//prohibit assignment between objects

	bool Is_lock_free ();/whether there is no lock
	void Store (T Value)//Deposit value
	t load ();//value
	t operator= (t v) volatile;//assignment
	operator T () volatile const;//implicit type conversion, equivalent to load
	T Exchange (t new_value);//deposit value, returning the original value
	bool Compare_exchange_weak (t &expected,t desired);
	bool Compare_exchange_strong (t &expected, t desired);/
	T & Storage ()//Get internal value
	T const& storage () const;//
};
Usage:
#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 = = && 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 (); }

Run Result:
2.414

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.