muduo 库解析之七：Atomic

_sync

Gcc 4.1.2 版本之后，对 X86 或 X86_64 支持内置原子操作。

//@ 将value加到*ptr上，结果更新到*ptr，并返回操作之前*ptr的值
type __sync_fetch_and_add (type *ptr, type value, ...)
//@ 从*ptr减去value，结果更新到*ptr，并返回操作之前*ptr的值
type __sync_fetch_and_sub (type *ptr, type value, ...)
//@ 将*ptr与value相或，结果更新到*ptr， 并返回操作之前*ptr的值
type __sync_fetch_and_or (type *ptr, type value, ...)
//@ 将*ptr与value相与，结果更新到*ptr，并返回操作之前*ptr的值
type __sync_fetch_and_and (type *ptr, type value, ...)
//@ 将*ptr与value异或，结果更新到*ptr，并返回操作之前*ptr的值
type __sync_fetch_and_xor (type *ptr, type value, ...)
//@ 将*ptr取反后，与value相与，结果更新到*ptr，并返回操作之前*ptr的值
type __sync_fetch_and_nand (type *ptr, type value, ...)

//@ 将value加到*ptr上，结果更新到*ptr，并返回操作之后新*ptr的值
type __sync_add_and_fetch (type *ptr, type value, ...)
//@ 从*ptr减去value，结果更新到*ptr，并返回操作之后新*ptr的值
type __sync_sub_and_fetch (type *ptr, type value, ...)
//@ 将*ptr与value相或， 结果更新到*ptr，并返回操作之后新*ptr的值
type __sync_or_and_fetch (type *ptr, type value, ...)
//@ 将*ptr与value相与，结果更新到*ptr，并返回操作之后新*ptr的值
type __sync_and_and_fetch (type *ptr, type value, ...)
//@ 将*ptr与value异或，结果更新到*ptr，并返回操作之后新*ptr的值
type __sync_xor_and_fetch (type *ptr, type value, ...)
//@ 将*ptr取反后，与value相与，结果更新到*ptr，并返回操作之后新*ptr的值
type __sync_nand_and_fetch (type *ptr, type value, ...)

//@ 比较*ptr与oldval的值，如果两者相等，则将newval更新到*ptr并返回true
bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)
//@ 比较*ptr与oldval的值，如果两者相等，则将newval更新到*ptr并返回操作之前*ptr的值
type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)

//@ 发出完整内存栅栏
__sync_synchronize (...)

//@ 将value写入*ptr，对*ptr加锁，并返回操作之前*ptr的值。即，try spinlock语义
type __sync_lock_test_and_set (type *ptr, type value, ...)

//@ 将0写入到*ptr，并对*ptr解锁。即，unlock spinlock语义
void __sync_lock_release (type *ptr, ...)

源码

Atomic.h

#pragma once

#include <stdint.h>

#include "NonCopyable.h"

namespace muduo
{
    namespace detail
    {
        template <typename T>
        class AtomicInteger : NonCopyable
        {
        public:
            AtomicInteger() : val_(0) {}

            T get()
            {
                // in gcc >= 4.7: __atomic_load_n(&value_, __ATOMIC_SEQ_CST)
                return __sync_val_compare_and_swap(&val_, 0, 0);
            }

            T get_and_add(T x)
            {
                // in gcc >= 4.7: __atomic_load_n(&value_, __ATOMIC_SEQ_CST)
                return __sync_fetch_and_add(&val_, x);
            }

            T add_and_get(T x)
            {
                return get_and_add(x) + x;
            }

            T increment_and_get()
            {
                return add_and_get(1);
            }

            T decrement_and_get()
            {
                return add_and_get(-1);
            }

            void add(T x)
            {
                get_and_add(x);
            }

            void increment()
            {
                increment_and_get();
            }

            void decrement()
            {
                decrement_and_get();
            }

            T get_and_set(T newValue)
            {
                // in gcc >= 4.7: __atomic_exchange_n(&value_, newValue, __ATOMIC_SEQ_CST)
                return __sync_lock_test_and_set(&val_, newValue);
            }

        private:
            T val_;
        };
    }

    //@ 预定义两个常用的类型
    typedef detail::AtomicInteger<int32_t> AtomicInt32;
    typedef detail::AtomicInteger<int64_t> AtomicInt64;
} // namespace muduo