聊聊 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 不失为不错的选择。