Qt原子操作之QBasicAtomicInt和QBasicAtomicInt

Qt之原子操作 QBasicAtomicPointer QBasicAtomicInt

原子操作：在多线程操作中，原子操作不会被线程调度机制打断。这种操作一旦开始就一直运行到结束，中间不会有上下文切换。

Qt为我们提提供了原子指针模板类，以及原子计数。我们分解介绍这两个类

QBasicAtomicPointer 

不多说上源码

template <typename T>
class QBasicAtomicPointer
{
public:
#ifdef QT_ARCH_PARISC
    int _q_lock[4];
#endif
#if defined(QT_ARCH_WINDOWS) || defined(QT_ARCH_WINDOWSCE)
    union {
        T * volatile _q_value;
#  if !defined(Q_OS_WINCE) && !defined(__i386__) && !defined(_M_IX86)
        qint64
#  else
        long
#  endif
        volatile _q_value_integral;
    };
#else
    T * volatile _q_value;
#endif

    // Non-atomic API
    inline bool operator==(T *value) const
    {
        return _q_value == value;
    }

    inline bool operator!=(T *value) const
    {
        return !operator==(value);
    }

    inline bool operator!() const
    {
        return operator==(0);
    }

    inline operator T *() const
    {
        return _q_value;
    }

    inline T *operator->() const
    {
        return _q_value;
    }

    inline QBasicAtomicPointer<T> &operator=(T *value)
    {
#ifdef QT_ARCH_PARISC
        this->_q_lock[0] = this->_q_lock[1] = this->_q_lock[2] = this->_q_lock[3] = -1;
#endif
        _q_value = value;
        return *this;
    }


    static bool isTestAndSetNative();
    static bool isTestAndSetWaitFree();

    bool testAndSetRelaxed(T *expectedValue, T *newValue);
    bool testAndSetAcquire(T *expectedValue, T *newValue);
    bool testAndSetRelease(T *expectedValue, T *newValue);
    bool testAndSetOrdered(T *expectedValue, T *newValue);

    static bool isFetchAndStoreNative();
    static bool isFetchAndStoreWaitFree();

    T *fetchAndStoreRelaxed(T *newValue);
    T *fetchAndStoreAcquire(T *newValue);
    T *fetchAndStoreRelease(T *newValue);
    T *fetchAndStoreOrdered(T *newValue);

    static bool isFetchAndAddNative();
    static bool isFetchAndAddWaitFree();

    T *fetchAndAddRelaxed(qptrdiff valueToAdd);
    T *fetchAndAddAcquire(qptrdiff valueToAdd);
    T *fetchAndAddRelease(qptrdiff valueToAdd);
    T *fetchAndAddOrdered(qptrdiff valueToAdd);
}

可以看到有成员 T * vlatile _q_value,以及一系列的 testAndSet ，fetchAndStore函数。

对于vlatile，  编译器在编译程序过程中，编译中间代码生成后，编译器对中间代码进行数据流分析从而对程序语句进行优化，达到较高的运行效率。但是这个优化会导致多线程运行的时候会导致读取变量的值不对，加上这个vlatile后，程序读取值会直接在值地址读取，而不会在寄存器中读取。保证了数据的安全性。

成员函数:

 刚才我们说到QBasicAtomicPointer 为我们提供了几种原子操作 test-and-set、fetch-and-store、fetch-and-add。其实这些函数的实现都定义了一种内存顺序的语义，这个语义描述了当处理器执行原子语句时怎么访问这些原子语句及其 前后的内存。因为当代的处理器架构允许对内存进行随意的访问，所以，为了让程序在所以的处理器上都能正确执行，使用一种合适的内存访问语义是至关重要的。在Qt中，为我们提供了4中内存模型：

首先看着几个关键词：

Relaxed - 即不具体指定内存访问的顺序，编译器和处理器可以自由的对内存访问进行重新排序。
Acquire  - 原子操作之后的内存访问（已程序的顺序）不会在原子操作之前被重新排序。
Release - 原子操作之前的内存访问（已程序的顺序）不会在原子操作之后被重新排序。
Ordered - Acquire 和 Release 的组合。

Test-and-set

  这些函数完成的功能是如果QBasicAtomicPointer 的当前值等于我们传入的期望值，则test-and-set函数会为其赋一个新值，然后返回true。如果当前值不等于传入的期望值，则这些函数声明也不干，直接返回false。

template <typename T>
Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
{
    unsigned char ret;
    asm volatile("lock\n"
                 "cmpxchg %3,%2\n"
                 "sete %1\n"
                 : "=a" (newValue), "=qm" (ret), "+m" (_q_value)
                 : "r" (newValue), "0" (expectedValue)
                 : "memory");
    return ret != 0;
}

等价于：

if (currentValue == expectedValue) {
      currentValue = newValue;
      return true;
  }
  return false;

fetch-and-store：

    fetch-and-store 函数的功能是读取QBasicAtomicPointer对象的当前值，并且为它设置一个我们传入的新值，然后返回读取到的旧值。

template <typename T>
Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
{
    asm volatile("xchg %0,%1"
                 : "=r" (newValue), "+m" (_q_value)
                 : "0" (newValue)
                 : "memory");
    return newValue;
}

等价于:

T* originalValue = currentValue;
  currentValue = newValue;
  return originalValue;

  Fetch-and-add

   fetch-and-add函数读取QAtomicPointer对象的当前值，然后为它加上我们传入的值，最后返回原来的值。

template <typename T>
Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
{
    asm volatile("lock\n"
                 "xadd %0,%1"
                 : "=r" (valueToAdd), "+m" (_q_value)
                 : "0" (valueToAdd * sizeof(T))
                 : "memory");
    return reinterpret_cast<T *>(valueToAdd);
}

等价于

T *current += valueToAdd * sizeof(T)
return current 

QBasicAtomicInt

QBasicAtomicInt 和QBasicAtomicPoint的结构类似，不过是把T * 换成int值了。