聊聊 volatile 關鍵字

原文地址： haifeiWu和他朋友們的博客
博客地址：www.hchstudio.cn
歡迎轉載，轉載請註明做者及出處，謝謝！

咱們知道 volatile 關鍵字的做用是保證變量在多線程之間的可見性，它是 java.util.concurrent 包的核心，沒有 volatile 就沒有這麼多的併發類給咱們使用。本文將簡單介紹一下 volatile 這個東東。

算法概念及其執行流程

• CAS(compare-and-swap) 是一種硬件對併發的支持，針對多處理器操做而設計的處理器中的一種特殊指令，用於管理對共享數據的併發訪問。

• CAS 是一種無鎖非阻塞算法的實現。

• CAS 包含了 3 個操做數：
  須要讀寫的內存值 V 進行比較的值 A
  擬寫入的新值 B

• 當且僅當 V 的值等於 A 時，CAS 經過原子方式用新值更新 V 的值，不然不會執行任何操做。

CAS 操做過程以下所示

CAS 算法模擬

/** * 模擬 CAS 算法 * * Created by wuhf on 2017-1-22. */
public class TestCompareAndSwap {
    public static void main(String[] args){
        final CompareAndSwap cas = new CompareAndSwap();

        for (int i = 0; i < 10; i++ ){
            new Thread(new Runnable() {
                        @Override
                        public void run() {
                            int expectValue = cas.getValue();
                            boolean b = cas.compareAndSet(expectValue, (int)(Math.random() * 101));
                            System.out.println(b);
                        }
                    }
            ).start();
        }
    }
}

class CompareAndSwap{
    private int value;

    // 獲取內存值
    public synchronized int getValue(){
        return this.value;
    }
    // 比較
    public synchronized int compareAndSwap(int expectValue,int newValue){
        int oldValue = this.value;
        if(oldValue == expectValue){//若是指望值等於舊值
            this.value = newValue;
        }
        return oldValue;
    }

    public synchronized boolean compareAndSet(int expectValue,int newValue){
        return expectValue == compareAndSwap(expectValue, newValue);
    }

}
複製代碼

原子變量

• 類的小工具包，支持在單個變量上解除鎖的線程安全編程。事實上，此包中的類可將 volatile 值、字段和數組元素的概念擴展到那些也提供原子條件更新操做的類。

• 類 AtomicBoolean、 AtomicInteger、 AtomicLong 和 AtomicReference 的實例各自提供對相應類型單個變量的訪問和更新。每一個類也爲該類型提供適當的實用工具方法。

• AtomicIntegerArray、 AtomicLongArray 和 AtomicReferenceArray 類進一步擴展了原子操做，對這些類型的數組提供了支持。這些類在爲其數組元素提供 volatile 訪問語義方面也引人注目，這對於普通數組來講是不受支持的。

• 核心方法： boolean compareAndSet(expectedValue, updateValue)

• java.util.concurrent.atomic 包下提供了一些原子操做的經常使用類:

1. AtomicBoolean 、 AtomicInteger 、 AtomicLong 、AtomicReference
2. AtomicIntegerArray 、 AtomicLongArray
3. AtomicMarkableReference
4. AtomicReferenceArray
5. AtomicStampedReference

原子變量簡單 Demo

/** * 1、i++ 的原子性問題：i++ 的操做實際上分爲三個步驟「讀-改-寫」 * int i = 10; * i = i++; //10 * * int temp = i; * i = i + 1; * i = temp; * 2、原子變量：在 java.util.concurrent.atomic 包下提供了一些原子變量。 * 1. volatile 保證內存可見性 * 2. CAS（Compare-And-Swap） 算法保證數據變量的原子性 * CAS 算法是硬件對於併發操做的支持 * CAS 包含了三個操做數： * 1,內存值 V * 2,預估值 A * 3,更新值 B * 當且僅當 V == A 時， V = B; 不然，不會執行任何操做。 */
public class AtomicDemo {
	public static void main(String[] args) {
		AtomicData ad = new AtomicData();
		for (int i = 0; i < 10; i++) {
			new Thread(ad).start();
		}
	}
}

class AtomicData implements Runnable{
	// 初始化原子變量
	private AtomicInteger atomicData = new AtomicInteger(0);
	
	@Override
	public void run() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(getAtomicData());
	}
	
	// 至關於atomicData++
	public int getAtomicData(){
		return atomicData.getAndIncrement();
	}
	
}
複製代碼

小結

在咱們的實現可能會被併發操做的共享資源時，加鎖可能會是最簡單粗暴的方法，可是使用不慎必然會產生死鎖等問題，而形成線程假死，產生重大線上問題。所以 volatile 不失爲不錯的選擇。