AtomicInteger的并发处理，Volatile修饰的成员变量

AtomicInteger 通俗地解释： 对某个内存值拷贝一个副本，某个线程若读到该副本，并对其进行计算，输出结果，在写入内存时，再次取出内存值和该副本比较，若副本和内存值相同，则把新的值写入内存。

较为官方的解释： 通过CAS（AtomicInteger）实现，CAS简而言之就是。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

两个问题：

（1）CAS算法仍然可能会出现冲突，例如A、B两个线程，A已经进入写内存但未完成，此时A读取到的副本且读取成功，AB两个线程同时进入写内存操作，必然会造成冲突。 CAS算法本质并非完全无锁，而是把获得锁和释放锁推迟至CPU原语实现，相当于尽可能的缩小了锁的范围；直接互斥地实现系统状态的改变，它的使用基本思想是copy-on-write——在修改完对象的副本之后再用CAS操作将副本替换为正本。

（2）ABA问题，若其中一个线程修改A->B->A，另外一个线程仍然读取到A，虽然值是预期值，但并不能说明该内存值没有变化。

JDK1.5之后的java.util.concurrent.atomic包里，多了一批原子处理类。主要用于在高并发环境下的高效程序处理。

网上关于这个原理介绍的比较靠谱的一片文章是出自IBM工程师的一篇：

流行的原子

 

值得一看。

这里，我们来看看AtomicInteger是如何使用非阻塞算法来实现并发控制的。

AtomicInteger的关键域只有一下3个：

 
Java代码  收藏代码

  

 // setup to use Unsafe.compareAndSwapInt for updates  
    private static final Unsafe unsafe = Unsafe.getUnsafe();  
    private static final long valueOffset;  
    private volatile int value;  

 这里， unsafe是java提供的获得对对象内存地址访问的类，注释已经清楚的写出了，它的作用就是在更新操作时提供“比较并替换”的作用。实际上就是AtomicInteger中的一个工具。

valueOffset是用来记录value本身在内存的便宜地址的，这个记录，也主要是为了在更新操作在内存中找到value的位置，方便比较。

注意：value是用来存储整数的时间变量，这里被声明为volatile，就是为了保证在更新操作时，当前线程可以拿到value最新的值（并发环境下，value可能已经被其他线程更新了）。

这里，我们以自增的代码为例，可以看到这个并发控制的核心算法：

 

 /**
        * Atomically increments by one the current value.
        *
        * @return the updated value
        */  
       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);  
       }  

 好了，看到这个代码，基本上就看到这个类的核心了。相对来说，其实这个类还是比较简单的。

private volatile int value; 

大家可以看到有这个变量，value就是你设置的自加起始值。注意看它的访问控制符，是volatile，这个就是保证AtomicInteger线程安全的根源，熟悉并发的同学一定知道在java中处理并发主要有两种方式：

1，synchronized关键字，这个大家应当都各种面试和笔试中经常遇到。

2，volatile修饰符的使用，相信这个修饰符大家平时在项目中使用的也不是很多。

 

这里重点说一下volatile:

Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存重新读取该成员的值，而且，当成员变量值发生变化时，强迫将变化的值重新写入共享内存，这样两个不同的线程在访问同一个共享变量的值时，始终看到的是同一个值。

 

java语言规范指出：为了获取最佳的运行速度，允许线程保留共享变量的副本，当这个线程进入或者离开同步代码块时，才与共享成员变量进行比对，如果有变化再更新共享成员变量。这样当多个线程同时访问一个共享变量时，可能会存在值不同步的现象。

 

而volatile这个值的作用就是告诉VM：对于这个成员变量不能保存它的副本，要直接与共享成员变量交互。

 

建议：当多个线程同时访问一个共享变量时，可以使用volatile，而当访问的变量已在synchronized代码块中时，不必使用。

缺点：使用volatile将使得VM优化失去作用，导致效率较低，所以要在必要的时候使用。

java多线程用法-使用AtomicInteger
下面通过简单的两个例子的对比来看一下 AtomicInteger 的强大的功能

class Counter {
private volatile int count = 0;

public synchronized void increment() {
count++;  //若要线程安全执行执行count++，需要加锁
}

public int getCount() {
return count;
}
}

class Counter {
private AtomicInteger count = new AtomicInteger();

public void increment() {
count.incrementAndGet();
}
       //使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
public int getCount() {
return count.get();
}
}

从上面的例子中我们可以看出：使用AtomicInteger是非常的安全的
那么为什么不使用记数器自加呢，例如count++这样的，因为这种计数是线程不安全的，高并发访问时统计会有误，而AtomicInteger为什么能够达到多而不乱，处理高并发应付自如呢？
这是由硬件提供原子操作指令实现的。在非激烈竞争的情况下，开销更小，速度更快。Java.util.concurrent中实现的原子操作类包括：
AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference。

看到网上一些资料对这个类的一些问题，这里简要摘录几个关键的，尝试解答一下：

1、为什么AtomicInteger里面的compareAndSet和weakCompareAndSet方法实现完全一样，注释说明却不同？

这个问题，一个老外的回答比较靠谱，这里给出链接：the difference between compareAndSet and weakCompareAndSet 。核心观点就是人家保留更改这个实现的权利。现在一样可能是暂时的，将来可能会不一样，所以使用接口时，还是按照人家接口说明来吧。

2、他比直接使用传统的java锁机制（阻塞的）有什么好处？

最大的好处就是可以避免多线程的优先级倒置和死锁情况的发生，当然高并发下的性能提升也是很重要的。

3、使用了他，并发环境下就一定没问题了吗？

这个还真未必！这个在上面那篇《流行的原子》文章中也提到了的ABA问题。在某些场景下，可能会造成业务问题。但是多数的场景（比如高效的计数器实现）是不用担心这个问题的。