主類模板
   gcc從4.1.2版本開始提供了__sync_*系列的內建API，用於加減和邏輯運算，可以對1，2，4，8位元組長度的數值或指標型別進行原子操作，為方便使用，筆者對這些API作了簡單的封裝。
 1template<typename T> 2class atomic_base 
 3{
 4public:
 5    typedef T int_type;
 6    typedef atomic_base<T> self_type;
 7
 8public:
 9    atomic_base(int_type val = int_type())

10    : val_(val)
11    {
12    }13
14    ~atomic_base()
15    {
16        BOOST_STATIC_ASSERT(sizeof(int_type)==1||sizeof(int_type)==2||sizeof(int_type)==4||sizeof(int_type)==8);
17    }18
19    atomic_base(const self_type& other)
20    {
21        int_type val = other;
22        __sync_lock_test_and_set(

&val_, val);
23    }24
25    self_type&operator= (const self_type& other)
26    {
27        if (this!=&other)
28        {
29            int_type val = other;
30            __sync_lock_test_and_set(&val_, val);
31        }32        return*this;
33    }34    
35    operator

 int_type() const36    {
37        return __sync_val_compare_and_swap(const_cast<volatile int_type*>(&val_),0,0);
38    }39    
40    self_type operator++(int)
41    {
42        return __sync_fetch_and_add(&val_,1);
43    }44
45    self_type&operator++()
46    {
47        __sync_add_and_fetch(&val_,1);
48        return*this;
49    }50
51    self_type operator--(int)
52    {
53        return __sync_fetch_and_sub(&val_,1);
54    }55
56    self_type&operator--()
57    {
58        __sync_sub_and_fetch(&val_,1);
59        return*this;
60    }61
62    self_type&operator+=(int_type val)
63    {
64        __sync_add_and_fetch(&val_,val);
65        return*this;
66    }67
68    self_type&operator-=(int_type val)
69    {
70        __sync_sub_and_fetch(&val_,val);
71        return*this;
72    }73
74    self_type&operator&=(int_type val)
75    { 
76        __sync_and_and_fetch(&val_, val); 
77        return*this;
78    }79
80    self_type&operator|=(int_type val)
81    {
82        __sync_or_and_fetch(&val_,val); 
83        return*this;
84    }85    
86    self_type&operator^=(int_type val)
87    {
88        __sync_xor_and_fetch(&val_,val); 
89        return*this;
90    }91
92private:
93    T val_;
94};    上面解構函式中，使用了BOOST_STATIC_ASSERT巨集來作編譯期約束，確保型別T大小為1，2，4，8位元組長度。由於提供了T到atomic_base的隱式轉換和轉型操作，因此沒有必要再定義operato +,operator - ,opeator ^,operator |,operator &運算子成員或友元過載操作。

指標型別偏特化
   由於主模板定義了operator+=,operator-=,operator&=,operator|=,operator^=運算子過載操作，但當T為指標型別時，指標的加減和邏輯運算沒有意義，但對於指標加減一個數值是有意義的，因此前兩者操作保留且重定義，但沒有後三者操作，需要特化實現：
 1template<typename T> 2class atomic_base<T*> 3{
 4public:
 5    typedef T* pointer_type;
 6    typedef atomic_base<T*> self_type;
 7
 8public:
 9    atomic_base(pointer_type val = NULL)
10        : val_(val)
11    {
12    }13
14    atomic_base(const self_type& other)
15    {
16        pointer_type val = other;
17        __sync_lock_test_and_set(&val_, val);
18    }19
20    ~atomic_base()
21    {
22        BOOST_STATIC_ASSERT(sizeof(pointer_type)==1||sizeof(pointer_type)==2||sizeof(pointer_type)==4||sizeof(pointer_type)==8);
23    }24
25    self_type&operator=(const self_type& other)
26    {
27        if (this!=&other)
28        {
29            pointer_type val = other;
30

相關推薦

GCC原子操作類模板

主類模板    gcc從4.1.2版本開始提供了__sync_*系列的內建API，用於加減和邏輯運算，可以對1，2，4，8位元組長度的數值或指標型別進行原子操作，為方便使用，筆者對這些API作了簡單的封裝。  1template<typename T> 2class a

原子操作類（一）原子操作類詳細介紹

expected 文章 span del 也有 pair 上一個 ride 操作類 引言 ??Java從JDK1.5開始提供了java.util.concurrent.atomic包，方便程序員在多線程環境下，無鎖的進行原子操作。原子變量的底層使用了處理器提供的原子指令，但

JAVA 原子操作類

上文中，guava程式碼中就用到了，在這裡再專門捋一下 部分內容源自： https://www.jianshu.com/p/712681f5aecd https://www.yiibai.com/java_concurrency/concurrency_atomiclong.html Atomi

java併發之原子操作類(AtomicLong原始碼分析)和非阻塞演算法

  背景 近年來，在併發演算法領域的大多數研究都側重於非阻塞演算法，這種演算法用底層的原子機器指令（例如比較併發交換指令）代替鎖來確保資料在併發訪問中的一致性。非阻塞演算法被廣泛的用於在作業系統和JVM中實現執行緒/程序排程機制、垃圾回收機制以及鎖和其他併發資料結構。 與基於鎖

Java併發程式設計（十一）Java中的原子操作類

一、原子操作類簡介 JDK1.5開始提供了java.util.concurrent.atomic包，其中有一系列用法簡單、效能高效、可以執行緒安全更新變數的原子操作類，目前（JDK1.7）大概有這麼些： 二、原子操作類實現原理 以AtomicInteger為例看下原始碼，其中的兩個

多執行緒學習筆記十三——java中的原子操作類

當程式更新一個變數時，如果多執行緒同時更新這個變數，可能得到期望之外的值，比如變 量i=1，A執行緒更新i+1，B執行緒也更新i+1，經過兩個執行緒操作之後可能i不等於3，而是等於2。因 為A和B執行緒在更新變數i的時候拿到的i都是1，這就是執行緒不安全

併發：Java中的13個原子操作類。

當程式更新一個變數時，如果多執行緒同時更新這個變數，可能得到期望之外的值，比如變數i=1，A執行緒更新i+1，B執行緒也更新i+1，經過兩個執行緒操作之後可能i不等於3，而是等於2。因為A和B執行緒在更新變數i的時候拿到的i都是1，這就是執行緒不安全的更新操作，通常我們會使用synchronized

併發程式設計-concurrent指南-原子操作類-AtomicInteger

在java併發程式設計中，會出現++，--等操作，但是這些不是原子性操作，這線上程安全上面就會出現相應的問題。因此java提供了相應類的原子性操作類。 1.AtomicInteger 　　 　　可以用原子方式更新的 int 值。有關原子變數屬性的描述，請參閱 java.util.concur

併發程式設計-concurrent指南-原子操作類-AtomicBoolean

類AtomicBoolean 　　 可以用原子方式更新的 boolean 值。有關原子變數屬性的描述，請參閱 java.util.concurrent.atomic 包規範。AtomicBoolean 可用在應用程式中（如以原子方式更新的標誌），但不能用於替換 Boolean。 2.建構函式 　　1.

Java 原子操作類詳解（AtomicInteger、AtomicIntegerArray等）

當程式更新一個變數時，如果多執行緒同時更新這個變數，可能得到期望之外的值，比如變數i=1，A執行緒更新i+1，B執行緒也更新i+1，經過兩個執行緒操作之後可能i不等於3，而是等於2。因為A和B執行緒在更新變數i的時候拿到的i都是1，這就是執行緒不安全的更新操作，通常我們會使

Java併發程式設計系列之十九：原子操作類

原子操作類簡介 當更新一個變數的時候，多出現資料爭用的時候可能出現所意想不到的情況。這時的一般策略是使用synchronized解決，因為synchronized能夠保證多個執行緒不會同時更新該變數。然而，從jdk 5之後，提供了粒度更細、量級更輕，並且在多核

java 執行緒安全的全域性計數器-AtomicInteger原子操作類

首先 , 測試一下正常程式碼 public class Test1 { public static int count = 0; public static void main(String[] args) { for (int i =

Java併發程式設計之原子操作類

原子操作類簡介 當更新一個變數的時候，多出現資料爭用的時候可能出現所意想不到的情況。這時的一般策略是使用synchronized解決，因為synchronized能夠保證多個執行緒不會同時更新該變數。然而，從jdk 5之後，提供了粒度更細、量級更輕，並且在多核處理器具有高效

JDK 原子操作類詳解（AtomicInteger、AtomicIntegerArray等）

當程式更新一個變數時，如果多執行緒同時更新這個變數，可能得到期望之外的值，比如變數i=1，A執行緒更新i+1，B執行緒也更新i+1，經過兩個執行緒操作之後可能i不等於3，而是等於2。因為A和B執行緒在更新變數i的時候拿到的i都是1，這就是執行緒不安全的更新操作，通常我們會使用

java原子操作類-原子陣列類

java還提供了通過原子方式更新數組裡的某個元素，Atomic包提供了以下4個類。 AtomicIntegerArray：原子更新整型數組裡的元素 AtomicLongArray：原子更新長整型數組裡的元素 AtomicReferenceArray：原子更新引用型別數組裡的

gcc原子操作與spinlock簡單對比

GCC 提供的原子操作gcc從4.1.2提供了__sync_*系列的built-in函式，用於提供加減和邏輯運算的原子操作。 type __sync_fetch_and_add (type *ptr, type value, ...) type __sync_fetch_

Java併發程式設計(八)------無鎖與無鎖類(原子操作類)

1. 無鎖的概念 無鎖主要有兩個特徵： 是無障礙的 保證有一個執行緒可以勝出 與無障礙相比，無障礙並不保證有競爭時一定能完成操作，因為如果它發現每次操作都會產生衝突，那它則會不停地嘗試。如果臨界區內的執行緒互相干擾，則會導致所有的執行緒會卡死在臨界區，那麼系統性能則

24.Java中atomic包中的原子操作類總結

tun 添加 原來 說明 array 內存地址 void rri delta 1. 原子操作類介紹 在並發編程中很容易出現並發安全的問題，有一個很簡單的例子就是多線程更新變量i=1,比如多個線程執行i++操作，就有可能獲取不到正確的值，而這個問題，最常用的方法是通過Sy

多執行緒程式設計學習八(原子操作類).

簡介 Java 在 JDK 1.5 中提供了 java.util.concurrent.atomic 包，這個包中的原子操作類提供了一種用法簡單、效能高效、執行緒安全地更新一個變數的方式。主要提供了四種類型的原子更新方式，分別是原子更新基本型別、原子更新陣列、原子更新引用和原子更新屬性。 Atomic 類基本

Java多執行緒之原子操作類

在併發程式設計中很容易出現併發安全問題，最簡單的例子就是多執行緒更新變數i=1，多個執行緒執行i++操作，就有可能獲取不到正確的值，而這個問題，最常用的方法是通過Synchronized進行控制來達到執行緒安全的目的。但是由於synchronized是採用的是悲觀鎖策略，並不是特別高效的一種解決方案。實際上，