2. 程式人生 > >AtomicInteger原始碼及CAS深度分析

AtomicInteger原始碼及CAS深度分析

阿新 • • 發佈：2019-02-02

1、原子類

  • 可以實現一些原子操作
  • 基於CAS
    下面就以AtomicInteger為例。

2、AtomicInteger

在沒有AtomicInteger之前，對於一個Integer的執行緒安全操作，是需要使用同步鎖來實現的，當然現在也可以通過ReentrantLock來實現，但是最好最方便的實現方式是採用AtomicInteger。

具體示例：

package com.collection.test;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 原子類的測試
 */
public class AtomicTest {
    private
 
 static AtomicInteger atomicInteger = new AtomicInteger();

    //獲取當前值
    public static void getCurrentValue(){
        System.out.println(atomicInteger.get());//-->0
    }

    //設定value值
    public static void setValue(){
        atomicInteger.set(12);//直接用12覆蓋舊值
        System.out.println(atomicInteger.get
 
());//-->12
    }

    //根據方法名稱getAndSet就知道先get，則最後返回的就是舊值，如果get在後，就是返回新值
    public static void getAndSet(){
        System.out.println(atomicInteger.getAndSet(15));//-->12
    }

    public static void getAndIncrement(){
        System.out.println(atomicInteger.getAndIncrement());//-->15
    }

    public
 
 static void getAndDecrement(){
        System.out.println(atomicInteger.getAndDecrement());//-->16
    }

    public static void getAndAdd(){
        System.out.println(atomicInteger.getAndAdd(10));//-->15
    }

    public static void incrementAndGet(){
        System.out.println(atomicInteger.incrementAndGet());//-->26
    }

    public static void decrementAndGet(){
        System.out.println(atomicInteger.decrementAndGet());//-->25
    }

    public static void addAndGet(){
        System.out.println(atomicInteger.addAndGet(20));//-->45
    }

    public static void main(String[] args) {
        AtomicTest test = new AtomicTest();
        test.getCurrentValue();
        test.setValue();
        //返回舊值系列
        test.getAndSet();
        test.getAndIncrement();
        test.getAndDecrement();
        test.getAndAdd();
        //返回新值系列
        test.incrementAndGet();
        test.decrementAndGet();
        test.addAndGet();

    }
}
private volatile int value;// 初始化值

    /**
     * 建立一個AtomicInteger，初始值value為initialValue
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * 建立一個AtomicInteger，初始值value為0
     */
    public AtomicInteger() {
    }

    /**
     * 返回value
     */
    public final int get() {
        return value;
    }

    /**
     * 為value設值（基於value），而其他操作是基於舊值<--get()
     */
    public final void set(int newValue) {
        value = newValue;
    }

    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

    /**
     * 基於CAS為舊值設定新值，採用無限迴圈，直到設定成功為止
     * 
     * @return 返回舊值
     */
    public final int getAndSet(int newValue) {
        for (;;) {
            int current = get();// 獲取當前值（舊值）
            if (compareAndSet(current, newValue))// CAS新值替代舊值
                return current;// 返回舊值
        }
    }

    /**
     * 當前值+1，採用無限迴圈，直到+1成功為止
     * @return the previous value 返回舊值
     */
    public final int getAndIncrement() {
        for (;;) {
            int current = get();//獲取當前值
            int next = current + 1;//當前值+1
            if (compareAndSet(current, next))//基於CAS賦值
                return current;
        }
    }

    /**
     * 當前值-1，採用無限迴圈，直到-1成功為止 
     * @return the previous value 返回舊值
     */
    public final int getAndDecrement() {
        for (;;) {
            int current = get();
            int next = current - 1;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * 當前值+delta，採用無限迴圈，直到+delta成功為止 
     * @return the previous value  返回舊值
     */
    public final int getAndAdd(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return current;
        }
    }

    /**
     * 當前值+1， 採用無限迴圈，直到+1成功為止
     * @return the updated value 返回新值
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;//返回新值
        }
    }

    /**
     * 當前值-1， 採用無限迴圈，直到-1成功為止 
     * @return the updated value 返回新值
     */
    public final int decrementAndGet() {
        for (;;) {
            int current = get();
            int next = current - 1;
            if (compareAndSet(current, next))
                return next;//返回新值
        }
    }

    /**
     * 當前值+delta，採用無限迴圈，直到+delta成功為止  
     * @return the updated value 返回新值
     */
    public final int addAndGet(int delta) {
        for (;;) {
            int current = get();
            int next = current + delta;
            if (compareAndSet(current, next))
                return next;//返回新值
        }
    }

    /**
     * 獲取當前值
     */
    public int intValue() {
        return get();
    }

說明：使用與原始碼都簡單到爆了！自己看看註釋。

注意：

value是volatile的，關於volatile的相關內容見《附2 volatile》，具體連結：http://www.cnblogs.com/java-zhao/p/5125698.html
單步操作：例如set()是直接對value進行操作的，不需要CAS，因為單步操作就是原子操作。
多步操作：例如getAndSet(int newValue)是兩步操作–>先獲取值，在設定值，所以需要原子化，這裡採用CAS實現。
對於方法是返回舊值還是新值，直接看方法是以get開頭（返回舊值）還是get結尾（返回新值）就好
CAS：比較CPU記憶體上的值是不是當前值current，如果是就換成新值update，如果不是，說明獲取值之後到設定值之前，該值已經被別人先一步設定過了，此時如果自己再設定值的話，需要在別人修改後的值的基礎上去操作，否則就會覆蓋別人的修改，所以這個時候會直接返回false，再進行無限迴圈，重新獲取當前值，然後再基於CAS進行加減操作。
如果還是不懂CAS，類比資料庫的樂觀鎖。
補充一個東西：

// setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

這是AtomicInteger的所有屬性，其中value存的是當前值，而當前值存放的記憶體地址可以通過valueOffset來確定。實際上是“value欄位相對Java物件的起始地址的偏移量”

public final boolean compareAndSet(int expect, int update) {
      return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
  }

CAS方法：通過對比“valueOffset上的value”與expect是否相同，來決定是否修改value值為update值。

CAS

CAS:Compare and Swap, 翻譯成比較並交換。

java.util.concurrent包中藉助CAS實現了區別於synchronouse同步鎖的一種樂觀鎖。
CAS應用

CAS有3個運算元，記憶體值V，舊的預期值A，要修改的新值B。當且僅當預期值A和記憶體值V相同時，將記憶體值V修改為B，否則什麼都不做。

非阻塞演算法 （nonblocking algorithms）

一個執行緒的失敗或者掛起不應該影響其他執行緒的失敗或掛起的演算法。

現代的CPU提供了特殊的指令，可以自動更新共享資料，而且能夠檢測到其他執行緒的干擾，而 compareAndSet() 就用這些代替了鎖定。

拿出AtomicInteger來研究在沒有鎖的情況下是如何做到資料正確性的。

private volatile int value;

首先毫無以為，在沒有鎖的機制下可能需要藉助volatile原語，保證執行緒間的資料是可見的（共享的）。

這樣才獲取變數的值的時候才能直接讀取。

public final int get() {
return value;
}

然後來看看++i是怎麼做到的。

public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
} }

在這裡採用了CAS操作，每次從記憶體中讀取資料然後將此資料和+1後的結果進行CAS操作，如果成功就返回結果，否則重試直到成功為止。

而compareAndSet利用JNI來完成CPU指令的操作。

public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

整體的過程就是這樣子的，利用CPU的CAS指令，同時藉助JNI來完成Java的非阻塞演算法。其它原子操作都是利用類似的特性完成的。

其中

unsafe.compareAndSwapInt(this, valueOffset, expect, update);
類似：
if (this == expect) {
this = update
return true;
} else {
return false;
}
那麼問題就來了，成功過程中需要2個步驟：比較this == expect，替換this = update，compareAndSwapInt如何這兩個步驟的原子性呢？ 參考CAS的原理。

CAS缺點

CAS雖然很高效的解決原子操作，但是CAS仍然存在三大問題。ABA問題，迴圈時間長開銷大和只能保證一個共享變數的原子操作

  1. ABA問題。因為CAS需要在操作值的時候檢查下值有沒有發生變化，如果沒有發生變化則更新，但是如果一個值原來是A，變成了B，又變成了A，那麼使用CAS進行檢查時會發現它的值沒有發生變化，但是實際上卻變化了。ABA問題的解決思路就是使用版本號。在變數前面追加上版本號，每次變數更新的時候把版本號加一，那麼A－B－A 就會變成1A-2B－3A。
    從Java1.5開始JDK的atomic包裡提供了一個類AtomicStampedReference來解決ABA問題。這個類的compareAndSet方法作用是首先檢查當前引用是否等於預期引用，並且當前標誌是否等於預期標誌，如果全部相等，則以原子方式將該引用和該標誌的值設定為給定的更新值。
    關於ABA問題參考文件: http://blog.hesey.net/2011/09/resolve-aba-by-atomicstampedreference.html
  2. 迴圈時間長開銷大。自旋CAS如果長時間不成功，會給CPU帶來非常大的執行開銷。如果JVM能支援處理器提供的pause指令那麼效率會有一定的提升，pause指令有兩個作用，第一它可以延遲流水線執行指令（de-pipeline）,使CPU不會消耗過多的執行資源，延遲的時間取決於具體實現的版本，在一些處理器上延遲時間是零。第二它可以避免在退出迴圈的時候因記憶體順序衝突（memory order violation）而引起CPU流水線被清空（CPU pipeline flush），從而提高CPU的執行效率。
  3. 只能保證一個共享變數的原子操作。當對一個共享變數執行操作時，我們可以使用迴圈CAS的方式來保證原子操作，但是對多個共享變數操作時，迴圈CAS就無法保證操作的原子性，這個時候就可以用鎖，或者有一個取巧的辦法，就是把多個共享變數合併成一個共享變數來操作。比如有兩個共享變數i＝2,j=a，合併一下ij=2a，然後用CAS來操作ij。從Java1.5開始JDK提供了AtomicReference類來保證引用物件之間的原子性，你可以把多個變數放在一個物件裡來進行CAS操作。

concurrent包的實現
由於java的CAS同時具有 volatile 讀和volatile寫的記憶體語義，因此Java執行緒之間的通訊現在有了下面四種方式：

A執行緒寫volatile變數，隨後B執行緒讀這個volatile變數。
A執行緒寫volatile變數，隨後B執行緒用CAS更新這個volatile變數。
A執行緒用CAS更新一個volatile變數，隨後B執行緒用CAS更新這個volatile變數。
A執行緒用CAS更新一個volatile變數，隨後B執行緒讀這個volatile變數。
Java的CAS會使用現代處理器上提供的高效機器級別原子指令，這些原子指令以原子方式對記憶體執行讀-改-寫操作，這是在多處理器中實現同步的關鍵（從本質上來說，能夠支援原子性讀-改-寫指令的計算機器，是順序計算圖靈機的非同步等價機器，因此任何現代的多處理器都會去支援某種能對記憶體執行原子性讀-改-寫操作的原子指令）。同時，volatile變數的讀/寫和CAS可以實現執行緒之間的通訊。把這些特性整合在一起，就形成了整個concurrent包得以實現的基石。如果我們仔細分析concurrent包的原始碼實現，會發現一個通用化的實現模式：

首先，宣告共享變數為volatile；
然後，使用CAS的原子條件更新來實現執行緒之間的同步；
同時，配合以volatile的讀/寫和CAS所具有的volatile讀和寫的記憶體語義來實現執行緒之間的通訊。
AQS，非阻塞資料結構和原子變數類（java.util.concurrent.atomic包中的類），這些concurrent包中的基礎類都是使用這種模式來實現的，而concurrent包中的高層類又是依賴於這些基礎類來實現的。從整體來看，concurrent包的實現示意圖如下：
這裡寫圖片描述

相關推薦

AtomicInteger原始碼及CAS深度分析

1、原子類 可以實現一些原子操作 基於CAS 下面就以AtomicInteger為例。 2、AtomicInteger 在沒有AtomicInteger之前，對於一個Integer的執行緒安全操作，是需要使用同步鎖來實現的，當然現在也可以通過Reen

10分鐘快速精通rollup.js——Vue.js原始碼打包原理深度分析

前言 本教程是rollup.js系列教程的最後一篇，我將基於目前非常流行的Vue.js框架，深度分析Vue.js原始碼打包過程，讓大家深入理解複雜的前端框架是如何利用rollup.js進行打包的。通過這一篇教程的學習，相信大家可以更好地應用rollup.js為自己的專案服務。 說明：本教程基於Vue

uboot原始碼及啟動過程分析

#include #include /*  *************************************************************************  *  * Jump vector table as in table 3.1 in [1]  *  *

【java基礎】ReentrantReadWriteLock原始碼及實現原理分析

繼承關係 ReadLock和WriteLock是ReentrantReadWriteLock的兩個內部類，Lock的上鎖和釋放鎖都是通過AQS來實現的。 AQS定義了獨佔模式的acquire()和release()方法，共享模式的acquireShared()和r

碼農會鎖，synchronized 物件頭結構(mark-word、Klass Pointer)、指標壓縮、鎖競爭，原始碼解毒、深度分析！

![](https://img-blog.csdnimg.cn/20201029091853182.png) 作者：小傅哥 部落格：[https://bugstack.cn](https://bugstack.cn) >沉澱、分享、成長，讓自己和他人都能有所收穫！

ThreadLocal的原理，原始碼深度分析及使用

文章簡介 ThreadLocal應該都比較熟悉，這篇文章會基於ThreadLocal的應用以及實現原理做一個全面的分析 內容導航 什麼是ThreadLocal ThreadLocal的使用 分析ThreadLocal的實現原理 ThreadLocal的應用場景及問題

HashMap原始碼及多執行緒併發問題深度分析

以前只知道HashMap是執行緒不安全的，拿來就用，也不會考慮會出現什麼後果，直到最近在學習中終於暴露出了HashMap的短板出來，可又百思不得其解，於是在網上拜讀了若干大牛有關HashMap的分析文章，發現他們其實寫於很早之前，而HashMap的原始碼都已

spring原始碼學習之路---深度分析IOC容器初始化過程（三）

分析FileSystemXmlApplicationContext的建構函式，到底都做了什麼，導致IOC容器初始化成功。 public FileSystemXmlApplicationContext(String[] configLocations, boolean ref

Toast原始碼深度分析

目錄介紹 1.最簡單的建立方法 1.1 Toast構造方法 1.2 最簡單的建立 1.3 簡單改造避免重複建立 1.4 為何會出現記憶體洩漏 1.5 吐司是系統級別的 2.原始碼分析 2.1 Toast(Context co

前程無憂爬蟲原始碼及分析（一）

一、網頁分析     1.1 關鍵字頁面(url入口)         首先在前程無憂網站上檢索關鍵詞"大資料"：      &n

SparkSQL 之 Shuffle Join 核心原理及應用深度剖析-Spark商業原始碼實戰

本套技術專欄是作者（秦凱新）平時工作的總結和昇華，通過從真實商業環境抽取案例進行總結和分享，並給出商業應用的調優建議和叢集環境容量規劃等內容，請持續關注本套部落格。版權宣告：禁止轉載，歡迎學習。QQ郵箱地址：[email protected]，如有任何商業交流，可隨時聯絡。

AtomicInteger 原始碼分析

AtomicInteger 支援原子更新的 int 值。 建立例項 /** * 可原子更新的 int 值 */ private volatile int value; /** * 建立初始值為 initialValue 的新 AtomicInteg

php中parse_url函式的原始碼及分析(scheme部分)

前言 看師傅們的文章時發現,parse_url出現的次數較多，單純parse_url解析漏洞的考題也有很多，在此研究一下原始碼(太菜了看不懂，待日後再補充Orz) 原始碼 在ext/standard/url.c檔案中 PHPAPI php_url *php_url_parse_ex(char const

各類識別、深度學習 開原始碼及文獻梳理

Deep Residual Networks Deep Residual Learning for Image Recognition https://github.com/KaimingHe/deep-residual-networks Id

JAVA CAS原理深度分析

CAS CAS:Compare and Swap, 翻譯成比較並交換。  java.util.concurrent包中藉助CAS實現了區別於synchronouse同步鎖的一種樂觀鎖。 本文先從CAS的應用說起，再深入原理解析。 CAS應用 CAS有3個運算元，記憶

JAVA資料庫連線，JDBC深度分析解析連結過程及方式

一、概念 Java DataBase Connectivity,是一種用於執行SQL語句的Java API,它由一組用Java語言編寫的類和介面組成。通過這些類和介面, JDBC把SQL語句傳送給不同型別的資料庫進行處理並接收處理結果。 二、JDBC兩大類 1.

Android UI註解框架 ButterKnife原始碼及原理分析

很開心，今天看到了一篇大神寫的部落格，對ButterKnife進行原始碼原理分析！看完之後學習到了很多新的知識，有關於自動生成程式碼的原理，以後有機會要自己寫一個註解框架！哈哈，如果能力夠的話！ 簡單介紹一下 ButterKnife是一個很不錯的View

Apache頂級專案8-Geode原始碼深度分析

Apache頂級專案介紹之Geode。Apache頂級專案介紹之8，我們重新恢復Apache頂級專案系列，較之前介紹系列，我們本文直入程式碼分析，原因有二，Geode即上文我們分析的Gemfire的開源版本，其二被逼無奈，閱讀原始碼查詢問題。 1. Geode

JAVA CAS原理深度分析 concurrent實現

java.util.concurrent包完全建立在CAS之上的，沒有CAS就不會有此包。可見CAS的重要性。 CAS CAS:Compare and Swap, 翻譯成比較並交換。  java.util.concurrent包中藉助CAS實現了區別於synchronou

ShiroFilterFactoryBean原始碼及阻截原理深入分析

Shiro提供了與Web整合的支援，其通過一個ShiroFilter入口來攔截需要安全控制的URL，然後進行相應的控制，ShiroFilter類似於如Strut2/SpringMVC這種web框架的前端控制器，其是安全控制的入口點，其負責讀取配置（如ini配置檔案），然後判斷URL是否需要登入/許可權等工