Atomic&Unsafe魔法类详解

什么是原子操作？

原子（atom）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为”不可被中断的一个或一系列操作” 。

相关术语

术语名称	英文	解释
缓存行	Cache line	缓存的最小操作单位
比较并交换	Compare and Swap	CAS操作需要输入两个数值，一个旧值（期望操作前的值）和一个新值，在操作期间先比较下在旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。
CPU流水线	CPU pipeline	CPU流水线的工作方式就象工业生产上的装配流水线，在CPU中由5~~6个不同功能的电路单元组成一条指令处理流水线，然后将一条X86指令分成5~~6步后再由这些电路单元分别执行，这样就能实现在一个CPU时钟周期完成一条指令，因此提高CPU的运算速度。
内存顺序冲突	Memory order violation	内存顺序冲突一般是由假共享引起，假共享是指多个CPU同时修改同一个缓存行的不同部分而引起其中一个CPU的操作无效，当出现这个内存顺序冲突时，CPU必须清空流水线。

多CPU原子操作的实现方式

前提：处理器自动保证基本内存操作的原子性，处理器保证从系统内存中读取或者写入一个字节是原子的，意思是当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。Pentium6和最新的处理器能自动保证单处理器对同一个缓存行里进行16/32/64位的操作时原子的，但是复杂的内存操作处理器是不能自动保证其原子性的，比如跨总线宽度、跨多个缓存行和跨页表的访问。但是，处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。

实现：2种加锁机制

1、缓存行加锁（基于缓存加锁，基于MESI协议）
2、总线加锁（锁住cpu和内存之间的通信）

缓存行加锁失效的场景：

1、CPU不支持缓存锁定

2、缓存数据过大，一个缓存行放不下

JAVA原子操作的实现

1、锁（对象锁）
2、CAS操作（利用处理器提供的指令实现原子操作，x86架构:CMPXCHG，ARM：LL/SC）。

Atomic

在Atomic包里一共有12个类，四种原子更新方式，分别是原子更新基本类型，原子更新数组，原子更新引用和原子更新字段。Atomic包里的类基本都是使用Unsafe实现的包装类

基本类：AtomicInteger、AtomicLong、AtomicBoolean；

引用类型：AtomicReference、AtomicReference的ABA实例、 AtomicStampedRerence、AtomicMarkableReference；

数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

属性原子修改器（Updater）：AtomicIntegerFieldUpdater、 AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

1、原子更新基本类型类

用于通过原子的方式更新基本类型，Atomic包提供了以下三个类：

AtomicBoolean：原子更新布尔类型。
AtomicInteger：原子更新整型。
AtomicLong：原子更新长整型。

AtomicInteger的常用方法如下：

int addAndGet(int delta) ：以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果
boolean compareAndSet(int expect, int update) ：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。
int getAndIncrement()：以原子方式将当前值加1，注意：这里返回的是自增前的值。
void lazySet(int newValue)：最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
int getAndSet(int newValue)：以原子方式设置为newValue的值，并返回旧值。

Atomic包提供了三种基本类型的原子更新，但是Java的基本类型里还有char，float和double等。那么问题来了，如何原子的更新其他的基本类型呢？Atomic包里的类基本都是使用Unsafe实现的，Unsafe只提供了三种CAS方法，compareAndSwapObject， compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现其是先把Boolean转换成整型，再使用compareAndSwapInt进行CAS，所以原子更新double也可以用类似的思路来实现。

public class AtomicIntegerTest {
    static AtomicInteger atomicInteger = new AtomicInteger();

    public static void main(String[] args) {
        for (int i = 0; i<10; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {

                    atomicInteger.incrementAndGet();
                }
            }).start();
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("自加10次数值：--->"+atomicInteger.get());
    }

}

2、原子更新数组类

通过原子的方式更新数组里的某个元素，Atomic包提供了以下三个类：

AtomicIntegerArray：原子更新整型数组里的元素。

AtomicLongArray：原子更新长整型数组里的元素。

AtomicReferenceArray：原子更新引用类型数组里的元素。

AtomicIntegerArray类主要是提供原子的方式更新数组里的整型，其常用方法如下

int addAndGet(int i, int delta)：

以原子方式将输入值与数组中索引i的元素相加。

boolean compareAndSet(int i, int expect, int update)：

如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值。

public class AtomicIntegerArrayTest {
    static int[] value = new int[]{1,2};
    static AtomicIntegerArray aiArray = new AtomicIntegerArray(value);


    public static void main(String[] args) {
        aiArray.getAndSet(0,3);
        if(!aiArray.compareAndSet(0,3,5)){
            System.out.println("更新失败");
        }
        System.out.println(aiArray.get(0));
        System.out.println(value[0]);
        if(aiArray.get(0) != value[0]){
            System.out.println("不相等");
        }
    }
}

5
1
不相等

3、原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子的更新多个变

量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下三个类：

AtomicReference：原子更新引用类型。

AtomicReferenceFieldUpdater：原子更新引用类型里的字段。

AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子的更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference(VinitialRef, boolean initialMark)

4、原子更新字段类

如果我们只需要某个类里的某个字段，那么就需要使用原子更新字段类，Atomic包提供了以下三个类：

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。

AtomicLongFieldUpdater：原子更新长整型字段的更新器。

AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值

与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。原子更新字段类都是抽象类，每次使用都时候必须使用静态方法newUpdater创建一个

更新器。原子更新类的字段的必须使用public volatile修饰符

5、AtomicInteger存在ABA问题

public class AtomicAbaProblemTest {
    static AtomicInteger atomicInteger = new AtomicInteger(1);
    public static void main(String[] args) {
        Thread main = new Thread(new Runnable() {
            @Override
            public void run() {
                int a = atomicInteger.get();
                System.out.println("操作线程"+Thread.currentThread().getName()+"--修改前操作数值:"+a);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                boolean isCasSuccess = atomicInteger.compareAndSet(a,2);
                if(isCasSuccess){
                    System.out.println("操作线程"+Thread.currentThread().getName()+"--Cas修改后操作数值:"+atomicInteger.get());
                }else{
                    System.out.println("CAS修改失败");
                }

            }
        },"主线程");

        Thread other = new Thread(new Runnable() {
            @Override
            public void run() {
                atomicInteger.incrementAndGet();// 1+1 = 2;
                System.out.println("操作线程"+Thread.currentThread().getName()+"--increase后值:"+atomicInteger.get());
                atomicInteger.decrementAndGet();// atomic-1 = 2-1;
                System.out.println("操作线程"+Thread.currentThread().getName()+"--decrease后值:"+atomicInteger.get());
            }
        },"干扰线程");

        main.start();
        other.start();

    }
}

自定义原子更新字段类

利用Unsafe类 + 字段偏移量定位应用类型

public class AtomicStudentAgeUpdater {
    private String name ;
    private volatile int age;

    private static final Unsafe unsafe = UnsafeInstance.reflectGetUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset(AtomicStudentAgeUpdater.class.getDeclaredField("age"));
            System.out.println("valueOffset:--->"+valueOffset);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    public void compareAndSwapAge(int old,int target){
        unsafe.compareAndSwapInt(this,valueOffset,old,target);
    }


    public AtomicStudentAgeUpdater(String name, int age){
        this.name = name;
        this.age = age;
    }

    public int getAge(){
        return this.age;
    }

    public static void main(String[] args) {
        AtomicStudentAgeUpdater updater = new AtomicStudentAgeUpdater("杨过",18);
        updater.compareAndSwapAge(18,56);

        System.out.println("真实的杨过年龄---"+updater.getAge());

    }
}

Unsafe魔法类

Unsafe是位于sun.misc包下的一个类，主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。
Unsafe类为一单例实现，提供静态方法getUnsafe获取Unsafe实例，当且仅当调用getUnsafe方法的类为引导类加载器所加载时才合法，否则抛出SecurityException异常

public class Unsafe { 
    // 单例对象 
    private static final Unsafe theUnsafe;
    private Unsafe() { }
    @CallerSensitive 
    public static Unsafe getUnsafe() { 
        Class var0 = Reflection.getCallerClass(); 
            // 仅在引导类加载器`BootstrapClassLoader`加载时才合法 
        if(!VM.isSystemDomainLoader(var0.getClassLoader())) { 
            throw new SecurityException("Unsafe"); 
        } else { 
            return theUnsafe; 
        }
    }
}

获取Unsafe实例

1、把调用Unsafe相关方法的类Demo所在jar包路径追加到默认的bootstrap路径中，使得A被引导类加载器加载
java -Xbootclasspath/Demo:${path} // 其中path为调用Unsafe相关方法的类所在jar包路径
2、通过反射获取单例对象theUnsafe

public class UnsafeInstance {

    public static Unsafe reflectGetUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

Unsafe功能介绍

Unsafe可以绕过JVM做一些操作，所以称之为魔法类。直接操作提供的API大致可分为

内存操作

这部分主要包含堆外内存的分配、拷贝、释放、给定地址值操作等方法。

CAS 原子操作

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5); 

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); 

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6)
    
public native long objectFieldOffset(Field var1);

线程调度

包括线程挂起、恢复、锁机制等方法。
**//取消阻塞线程 **

public native void unpark(Object thread);

**//阻塞线程 **

public native void park(boolean isAbsolute, long time);

**//获得对象锁（类似可重入锁ReentrantLock或者Synchronized） **

public native void monitorEnter(Object o);

**//释放对象锁 **

public native void monitorExit(Object o);

//尝试获取对象锁

public native boolean tryMonitorEnter(Object o);

方法park、unpark即可实现线程的挂起与恢复，将一个线程进行挂起是通过park方法实现的，调用park方法后，线程将一直阻塞直到超时或者中断等条件出现； unpark可以终止一个挂起的线程，使其恢复正常

典型应用：Java锁和同步器框架的核心类AbstractQueuedSynchronizer，就是通过调用 LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的，而 LockSupport的park、unpark方法实际是调用Unsafe的park、unpark方式来实现。

内存屏障

在Java 8中引入，用于定义内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。

//内存屏障前后，禁止load操作重排序。屏障前的load操作不能被重排序到屏障后，屏障后的load操作不能被重排序到屏障前 
public native void loadFence(); 相当于loadload屏障
//内存屏障前后，禁止store操作重排序。屏障前的store操作不能被重排序到屏障后， 屏障后的store操作不能被重排序到屏障前
public native void storeFence(); 相当于storestore屏障
//内存屏障前后，禁止load、store操作重排序 
public native void fullFence(); 相当于 loadFence() + storeFence() ;使所有Full Barrier之前发生的操作，对所有Full Barrier之后的操作都是可见的

/**
 * @description :利用内存屏障手动防止指令
 */
public class FenceTest {


//    public static void main(String[] args) {
//
//        UnsafeInstance.reflectGetUnsafe().loadFence();//读屏障
//
//        UnsafeInstance.reflectGetUnsafe().storeFence();//写屏障
//
//        UnsafeInstance.reflectGetUnsafe().fullFence();//读写屏障
//
//    }

    private static int x = 0, y = 0;
    private static int a = 0, b =0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;

        for (;;){
            i++;
            x = 0; y = 0;
            a = 0; b = 0;
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    //由于线程one先启动，下面这句话让它等一等线程two. 读着可根据自己电脑的实际性能适当调整等待时间.
                    shortWait((long) (Math.random() * 100));
                    a = 1;
                    //不允许2次store操作发生重排
                    //手动加内存屏障
                    UnsafeInstance.reflectGetUnsafe().storeFence();
                    x = b; // read-load、assign、store-write
                    //分两步进行，第一步先volatile读，第二步再普通写
                }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    shortWait((long) (Math.random() * 100));
                    b = 1;
                    //不允许2次store操作发生重排
                    UnsafeInstance.reflectGetUnsafe().storeFence();
                    y = a;
                }
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();

            /**
             * cpu或者jit对我们的代码进行了指令重排？
             * 1,1
             * 0,1
             * 1,0
             * 0,0
             */
            String result = "第" + i + "次 (" + x + "," + y + "）";
            if(x == 0 && y == 0) {
                System.err.println(result);
                break;
            } else {
                System.out.println(result);
            }
        }

    }

    public static void shortWait(long interval){
        long start = System.nanoTime();
        long end;
        do{
            end = System.nanoTime();
        }while(start + interval >= end);
    }

}

Class相关
对象操作
系统信息获取
数组操做

24khandsome's Blog

并发编程05-Atomic&Unsafe魔法类详解