AtomicInteger 源码

基础介绍

    要对AtomicInteger有一个深入的认识，就必须要了解一下悲观锁和乐观锁。
    cpu是时分复用的,也就是把cpu的时间片，分配给不同的线程进程轮流执行，
    时间片与时间片之间，需要进行cpu切换，也就是会发生进程的切换。切换涉及到清空
    寄存器，缓存数据。然后重新加载新的thread所需数据。
    当一个线程被挂起时，加入到阻塞队列，在一定的时间或条件下，在通过
    notify()，notifyAll()唤醒回来。在某个资源不可用的时候，就将cpu让出，
    把当前等待线程切换为阻塞状态。等到资源(比如一个共享数据）可用了，那么就将线程唤醒，
    让他进入runnable状态等待cpu调度。这就是典型的悲观锁的实现。

    但是，由于在进程挂起和恢复执行过程中存在着很大的开销。当一个线程正在等待锁时，
    它不能做任何事，所以悲观锁有很大的缺点。举个例子，如果一个线程需要某个资源，但是
    这个资源的占用时间很短，当线程第一次抢占这个资源时，可能这个资源被占用，如果此时挂起
    这个线程，可能立刻就发现资源可用，然后又需要花费很长的时间重新抢占锁，时间代价
    就会非常的高。

    所以就有了乐观锁的概念，他的核心思路就是，每次不加锁而是假设没有冲突而去完成某项操作，
    如果因为冲突失败就重试，直到成功为止。在上面的例子中，某个线程可以不让出cpu,而是一直
    while循环，如果失败就重试，直到成功为止。所以，当数据争用不严重时，乐观锁效果更好。
    比如我们要说的AtomicInteger底层同步CAS就是一种乐观锁思想的应用。

    CAS就是Compare and Swap的意思，比较并操作。很多的cpu直接支持CAS指令。CAS是项
    乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，
    而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
    CAS有3个操作数，内存值V，预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，

将内存值V修改为B，否则什么都不做。

---

</br>

CAS操作

CAS通过调用JNI的代码实现的。JNI:Java Native Interface为JAVA本地调用，允许java调用其他语言。而compareAndSwapInt就是借助C来调用CPU底层指令实现的。#lock类似的cpu指令.

AtomicInteger内部有一个变量UnSafe：
private static final Unsafe unsafe = Unsafe.getUnsafe();

Unsafe类是一个可以执行不安全、容易犯错的操作的一个特殊类。虽然Unsafe类中所有方法都是public的，但是这个类只能在一些被信任的代码中使用。其实CAS指的是sun.misc.Unsafe这个类中的一些方法的统称。例如，Unsafe这个类中有compareAndSwapInt、compareAndSwapLong等方法。

public final native boolean compareAndSwapInt(Object o, long V, int E, int N);
  CAS的过程是：它包含了3个参数CAS(O,V,E,N)。O表示要更新的对象。V表示指明更新的对象中的哪个变量，E是进行比较的值，如果V==E，则将N赋值给V。
  第二个参数V(offset)，其实要更新的对象里的字段相对于对象初始位置的内存偏移量。通俗一点就是在CAS(O,V,E,N)中，O是你要更新那个对象，
V就是我要通过这个偏移量找到这个对象中的value对象，来对他进行操作。也就是说，如果我把1这个数字属性更新到2的话，需要这样调用：

compareAndSwapInt(this, valueOffset, 1, 2);

valueOffset字段表示内存位置，可以在AtomicInteger对象中使用unsafe得到：

static {
try { 
  valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); 
} catch (Exception ex) {
  throw new Error(ex); }
}

AtomicInteger内部使用变量value表示当前的整型值，这个整型变量还是volatile的，表示内存可见性，一个线程修改value之后保证对其他线程的可见性：

private volatile int value;

AtomicInteger内部还封装了一下CAS，定义了一个compareAndSet方法，只需要2个参数：

public final boolean compareAndSet(int expect, int update) {
 return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

---

其中
unsafe.compareAndSwapInt(this, valueOffset, expect, update);
类似于：
if (this == expect) {
  this = update;
  return true;
} else {
  return false;
}

---

具体函数说明

public class AtomicInteger extends Number implements java.io.Serializable {  
    private static final long serialVersionUID = 6214790243416807050L;  
  
  
    private static final Unsafe unsafe = Unsafe.getUnsafe(); //这里是初始化一个Unsafe对象。因为CAS是这个类中的方法。  
    private static final long valueOffset;  
  
    static {  
      try {  
          
          /*一个java对象可以看成是一段内存，各个字段都得按照一定的顺序放在这段内存里， 
          同时考虑到对齐要求，可能这些字段不是连续放置的，用这个方法能准确地告诉你某个 
          字段(也就是下面的value字段)相对于对象的起始内存地址的字节偏移量，因为是相对 
          偏移量，所以它其实跟某个具体对象又没什么太大关系，跟class的定义和虚拟机的内 
          存模型的实现细节更相关。通俗一点就是在CAS(O,V,E,N)中，O是你要更新那个对象， 
          V就是我要通过这个偏移量找到这个对象中的value对象，来对他进行操作。*/  
            
        valueOffset = unsafe.objectFieldOffset  
            (AtomicInteger.class.getDeclaredField("value"));   
      } catch (Exception ex) { throw new Error(ex); }  
    }  
    //volatile,保证变量的可见性。  
    private volatile int value;  
  
    //有参构造  
    public AtomicInteger(int initialValue) {  
        value = initialValue;  
    }  
  
     
    public AtomicInteger() {  
    }  
      
    public final int get() {  
        return value;  
    }  
      
    public final int getAndIncrement() {  
        //为什么会无限循环，先得到当前的值value，然后再把当前的值加1
        //加完之后使用cas原子操作让当前值加1处理正确。当然cas原子操作不一定是成功的，
        //所以做了一个死循环，当cas操作成功的时候返回数据。这里由于使用了cas原子操作，
        //所以不会出现多线程处理错误的问题。
        //比如，
        //   1. Thread-A进入循环获取current＝1，然后切下cpu，Thread-B上cpu得到current＝1再下cpu；
        //   2. 然后Thread-A的next值为2，进行cas操作并且成功的时候，将value修改成了2；这时候内存中value值为2了,
        //      这个时候Thread-B切上cpu执行的next值为2，当进行cas操作的时候由于expected值已经是2，而不是1了；所以cas操作会失败，
        //   3. 失败了怎么办，在下个循环中得到的current就变成了2；也就不会出现多线程处理问题了！
        for (;;) {  
            int current = get(); //得到当前的值  
            int next = current + 1;  
            if (compareAndSet(current, next))  
                return current;  
        }  
    }  
  
    
    public final boolean compareAndSet(int expect, int update) {  
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
    }  
      
} 

---

CAS缺点

  CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。
－－－ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作。

  1. ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

  2. 循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

  3. 只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。