J.U.C 系列之Atomic原子类

一 什么是原子类?

所谓原子类必然是具有原子性的类，原子性操作--原子操作，百度百科中给的定义如下

"原子操作(atomic operation)是不需要synchronized"，这是Java多线程编程的老生常谈了。所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切^[1]  换到另一个线程）。

顾名思义，原子类就是一个一旦被执行就不能中断的类。

二 为什么需要原子类？

在看为什么需要原子类之前，我们看看普通Number类,在处理问题时可能存在的问题，这里我们通过Integer来演示

public class Main {

    private static Integer sum = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(new Task()).start();
        }

        Thread.yield();
        System.out.println(sum);

    }

    static class Task implements Runnable {
        @Override
        public void run() {
            for(int i = 0;i<100;i++){
                sum++;
            }
        }
    }
}

这段代码意思是开20个线程，每个线程对sum自加100次，理论上应该最后输出2000；但是事实上每次都是小于2000；

这是听说过volatile关键字的小伙伴可能会说，使用volatile来修饰sum,好，我们继续试验

public class Main {

    private static volatile Integer sum = 0;

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(new Task()).start();
        }

        Thread.yield();
        System.out.println(sum);

    }

    static class Task implements Runnable {
        @Override
        public void run() {
            for(int i = 0;i<100;i++){
                sum++;
            }
        }
    }
}

这是试验五次的输出

1766，1616，1859，1980，1800

还是都是小于2000，这是怎么回事，这里先提一下，volatile只能保证单个操作的原子性，而sum++，包括三个操作

sum = getSum()  //读取sum

temp = sum +1;  //sum+1,赋给临时变量

sum =  setSum(temp)      //将sum写回

因此，即使是volatile也无法保证sum++的原子性，volatile只能保证单个操作的原子性，而++操作是复合操作，volatile变量会在后续章节详细讨论；

那么，在Atomic未出现之前，是如何处理i++在多线程环境下的线程安全问题，主要是通过Synchronize加锁来处理，处理过程复杂，性能低

JDK5.0之后出现的Java.util.concurrent.Atomic包中为我们提供了13中原子类，来保证单个原子变量复合操作的原子性。下面我们通过AtomicInteger的使用来认识一下原子类

三 原子类示例详解

AtomicInteger 字段

　　 // setup to use Unsafe.compareAndSwapInt for updates
　　 //这里， unsafe是java提供的获得对对象内存地址访问的类，注释已经清楚的写出了，它的作用就是在更新操作时提供“比较并替换”的作用。实际上就是AtomicInteger中的一个工具。
    private static final Unsafe unsafe = Unsafe.getUnsafe();
　　 //valueOffset是用来记录value本身在内存的便宜地址的，这个记录，也主要是为了在更新操作在内存中找到value的位置，方便比较。
    private static final long valueOffset;
　 　//value是用来存储整数的时间变量，这里被声明为volatile，就是为了保证在更新操作时，当前线程可以拿到value最新的值（并发环境下，value可能已经被其他线程更新了）。
    private volatile int value;

AtomicInteger 构造方法

 /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }

AtomicInteger 并发安全实现

那么AtomicInteger是如何实现多线程的自增操作的线程安全的呢？核心思想就是CAS自旋；CAS:Compare And Swap 比较并交换。自旋：通过循环知道预期值和内存之相同，进行CAS操作，AtomicInteger的自增如下所示

       public final int incrementAndGet() {  
           for (;;) {  
               //这里可以拿到value的最新内存值
               int current = get();  
               int next = current + 1;  
               if (compareAndSet(current, next))  
                   return next;  
           }  
       }  
      
       public final boolean compareAndSet(int expect, int update) {  
           //使用unsafe的native方法，实现高效的硬件级别CAS  
       return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
       }  

 AtomicInteger 其他常用方法

　　/**
     * 返回旧值，然后自增1
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    /**
     * 返回旧值，然后自减1
     *
     * @return the previous value
     */
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

    /**
     * 返回旧值，然后  旧值+delta
     *
     * @param delta the value to add
     * @return the previous value
     */
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

    /**
     * 先进行自增，返回自增后的值
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    /**
     * 先进行自减，然后返回自减后的值
     *
     * @return the updated value
     */
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }

    /**
     *先在原值上加delta，再返回加之后的值
     *
     * @param delta the value to add
     * @return the updated value
     */
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

注：其他Atomic类类似，不一一介绍；

四 Atomic 存在的问题

    》 长时间自旋，导致CPU和资源的占用

　 》 只能保证单个原子变量的多线程安全操作，当然可以将多个变量封装成一个类,通过原子引用类型实现

　 》 ABA问题；使用AtomicStampedReference 原子更新带有版本号的引用类型解决