Java并发包中主要基于两个基础来构建的，一个是锁，一个是CAS操作。

与文无关

• 原子变量提供了与volatile类型变量相同的内存语义，此外还支持原子性操作。从JDK1.5开始，提供了java.util.concurrent.atomic包，这个包中的原子操作提供了一种用法简单，性能高效，线程安全的更新一个变量的方式。原子类采用非阻塞算法CAS实现
• 非阻塞算法可以使多个线程在竞争相同的数据时不会发生阻塞。独占锁可以看做是一种悲观锁，它假设只要有线程进入就会导致错误，因此只在确保无其它线程进入的时候才进行操作；非阻塞算法，则只关心结果，如果结果错误了，那么重新再来，对于错误选择原谅，而不是想进办法防止其它线程进入，使用非阻塞算法无需关心其它线程。

Java中对非阻塞算法的支持是java.util.concurrent.atomic包中的原子类。

原子类划分

基本类型：AtomicBoolean,AtomicInteger,AtomicLong
数组： AtomicIntegerArray,AtomicLongArray,AtomicRefernceArray
引用类型：AtomicReference, AtomicReferenceFieldUpdater,AtomicMarkableReference
字段类：AtomicIntegerFieldUpdater,AtomicLongFieldUpdater,AtomicStampedReference

CAS算法

原子类的操作本质上都是CAS算法的实现。
CAS算法过程：
CAS包含了3个操作数，需要读写的内存位置V，进行比较的值E(exists)，和要写入的值N(new)。
当且仅当V的值等于E的值的时候，才会把V的值设置成N。最后CAS返回V的真实值。

原子类案例

原子类是一种更好的volatile变量，之前我们保证同步的措施是使用加锁的机制，无需加锁，也可以做到。

原子类的核心API实现

基本上所有原子类都有这些API，它们的操作也都是利用这些API实现的。而这些API又都是利用Unsafe类来实现的。
如果我们直接实例化Unsafe类，系统会报SecurityException异常，平时开发中也不建议使用Unsafe类来做各种操作，但是有关Unsafe类的一些用法可以了解下。

Unsafe类可以直接操作内存层面上的数据。

compareAndSet(V,E,N)

    //在对象var1变量上，var2为地址，var4期望的值，var5位要设置的新值。
    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 class IntegerDemo implements Runnable{
    static AtomicInteger count = new AtomicInteger(0);
    static int THREAD_COUNT = 100;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // CAS自增语句
            count.incrementAndGet();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        IntegerDemo demo = new IntegerDemo();
        Thread[] threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i]  = new Thread(demo);
            threads[i].start();
        }

        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i].join();
        }

        System.out.println(count.get());
    }
}
//可以看到每次结果都是: 10000

这段代码中重要的是原子类的incrementAndGet方法，看一下内部实现。

    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        // 不断循环，以确保值正确
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }    
    
    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);    

原子引用类型案例

关于AtomicRefernce的使用

public class ReferenceDemo {

    private static AtomicReference<Integer> count = new AtomicReference<>(0);

    public static void main(String[] args) {
        count.compareAndSet(0, 2); // 2
        count.compareAndSet(0, 1); // no
        count.compareAndSet(1, 3); // no
        count.compareAndSet(2, 4); // 4
        count.compareAndSet(3, 5); // no
        System.out.println(count.get());
    }

}
//运行结果得4

//通过CAS算法，修改对象成员变量的值
// 要求成员变量是非静态类型变量最好是volatile修饰的
public class ReferenceFiledUpdaterDemo {

    private static AtomicIntegerFieldUpdater<ReferenceFiledUpdaterDemo> updater =
            AtomicIntegerFieldUpdater.newUpdater(ReferenceFiledUpdaterDemo.class, "count");

    @Getter
    public volatile int count = 100;

    public static void main(String[] args) {
        ReferenceFiledUpdaterDemo demo = new ReferenceFiledUpdaterDemo();
        if (updater.compareAndSet(demo, 100, 120)) {
            System.out.println(("update success 1 :" + demo.getCount()));
        }

        if (updater.compareAndSet(demo, 100, 120)) {
            System.out.println(("update success 2 :" +  demo.getCount()));
        } else {
            System.out.println(("update failed  :" +  demo.getCount()));
        }
    }
}

//运行结果
update success :120
update failed, {} :120

AtomicReference无法解决ABA问题，所谓ABA问题，对象在某一段时间内被写入了两次，首先修改为其它的值，然后又修改回原来的值，而另外一个线程再去读的时候值并没有变化，如何知道对象是否被修改过呢？

JDK中引入了AtomicStampedReference，它维护了一个时间戳，更新数据的时候还要更新时间戳，当对象值，及时间戳都满足期望值的时候才能写入成功。

原子类数组案例

AtomicArray的核心API

public class AtomicArrayDemo {
    static AtomicIntegerArray arr = new AtomicIntegerArray(10);
    public static class SubThread implements Runnable{

        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                arr.getAndDecrement( i % arr.length() );
            }
        }
    }

    public static void main(String[] args) {
        Runnable demo = new SubThread();
        ExecutorService service = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            service.submit(demo);
        }
        service.shutdown();
        System.out.println(arr);
    }
}
//运行结果
[-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000]

三种原子性机制对比

对比

最后

这次主要对原子类相关的内容做了简单的说明，需要明白原子类的用法以及Unsafe类的一些事项。

参考

• Java Magic. Part 4: sun.misc.Unsafe
• 《Java并发编程实战》
• 《Java高并发程序设计》