Atomic包实现原理

标签：java   atomic   atomicinteger   

Atomic简介

Atomic包是java.util.concurrent下的另一个专门为线程安全设计的Java包，包含多个原子操作类。这个包里面提供了一组原子变量类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。可以对基本数据、数组中的基本数据、对类中的基本数据进行操作。原子变量类相当于一种泛化的volatile变量，能够支持原子的和有条件的读-改-写操作。——  引自@chenzehe 的博客。

传统锁的问题

我们先来看一个例子：计数器（Counter），采用Java里比较方便的锁机制synchronized关键字，初步的代码如下：

[java] view plaincopy

1. class Counter {  
2.           
3.     private int value;  
4.   
5.     public synchronized int getValue() {  
6.         return value;  
7.     }  
8.   
9.     public synchronized int increment() {  
10.         return ++value;  
11.     }  
12.   
13.     public synchronized int decrement() {  
14.         return --value;  
15.     }  
16. }   

硬件同步策略

现在的处理器都支持多重处理，当然也包含多个处理器共享外围设备和内存，同时，加强了指令集以支持一些多处理的特殊需求。特别是几乎所有的处理器都可以将其他处理器阻塞以便更新共享变量。

Compare and swap(CAS)

当前的处理器基本都支持CAS，只不过每个厂家所实现的算法并不一样罢了，每一个CAS操作过程都包含三个运算符：一个内存地址V，一个期望的值A和一个新值B，操作的时候如果这个地址上存放的值等于这个期望的值A，则将地址上的值赋为新值B，否则不做任何操作。CAS的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事儿，但是要返回原值是多少。我们来看一个例子，解释CAS的实现过程（并非真实的CAS实现）：

[java] view plaincopy

1. class SimulatedCAS {  
2.     private int value;  
3.   
4.     public synchronized int getValue() {  
5.         return value;  
6.     }  
7.     public synchronized int compareAndSwap(int expectedValue, int newValue) {  
8.         int oldValue = value;  
9.         if (value == expectedValue)  
10.             value = newValue;  
11.         return oldValue;  
12.     }  
13. }  

[java] view plaincopy

1. public class CasCounter {  
2.     private SimulatedCAS value;  
3.   
4.     public int getValue() {  
5.         return value.getValue();  
6.     }  
7.   
8.     public int increment() {  
9.         int oldValue = value.getValue();  
10.         while (value.compareAndSwap(oldValue, oldValue + 1) != oldValue)  
11.             oldValue = value.getValue();  
12.         return oldValue + 1;  
13.     }  
14. }  

Atomic类

• 标量类：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
• 数组类：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
• 更新器类：AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
• 复合变量类：AtomicMarkableReference，AtomicStampedReference

第一组AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference这四种基本类型用来处理布尔，整数，长整数，对象四种数据，其内部实现不是简单的使用synchronized，而是一个更为高效的方式CAS (compare and swap) + volatile和native方法，从而避免了synchronized的高开销，执行效率大为提升。我们来看个例子，与我们平时i++所对应的原子操作为：getAndIncrement()

[java] view plaincopy

1. public static void main(String[] args) {  
2.     AtomicInteger ai = new AtomicInteger();  
3.     System.out.println(ai);  
4.     ai.getAndIncrement();  
5.     System.out.println(ai);  
6. }  

[java] view plaincopy

1. /** 
2.  * Atomically increments by one the current value. 
3.  * 
4.  * @return the previous value 
5.  */  
6. public final int getAndIncrement() {  
7.     return unsafe.getAndAddInt(this, valueOffset, 1);  
8. }  

从源码注释得知，这个类是用于执行低级别、不安全操作的方法集合。尽管这个类和所有的方法都是公开的（public），但是这个类的使用仍然受限，你无法在自己的java程序中直接使用该类，因为只有授信的代码才能获得该类的实例。所以我们平时的代码是无法使用这个类的，因为其设计的操作过于偏底层，如若操作不慎可能会带来很大的灾难，所以直接禁止普通代码的访问，当然JDK使用是没有问题的。

Atomic中的CAS

从前面的解释得知，CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值，此处这个“原本的一个值”怎么来，我们看看AtomicInteger里的实现：

[java] view plaincopy

1. // setup to use Unsafe.compareAndSwapInt for updates  
2.     private static final Unsafe unsafe = Unsafe.getUnsafe();  
3.     private static final long valueOffset;  
4.   
5.     static {  
6.         try {  
7.             valueOffset = unsafe.objectFieldOffset  
8.                 (AtomicInteger.class.getDeclaredField("value"));  
9.         } catch (Exception ex) { throw new Error(ex); }  
10.     }  

[java] view plaincopy

1. /** 
2.      * Report the location of a given static field, in conjunction with {@link 
3.      * #staticFieldBase}. 
4.      * <p>Do not expect to perform any sort of arithmetic on this offset; 
5.      * it is just a cookie which is passed to the unsafe heap memory accessors. 
6.      * 
7.      * <p>Any given field will always have the same offset, and no two distinct 
8.      * fields of the same class will ever have the same offset. 
9.      * 
10.      * <p>As of 1.4.1, offsets for fields are represented as long values, 
11.      * although the Sun JVM does not use the most significant 32 bits. 
12.      * It is hard to imagine a JVM technology which needs more than 
13.      * a few bits to encode an offset within a non-array object, 
14.      * However, for consistency with other methods in this class, 
15.      * this method reports its result as a long value. 
16.      * @see #getInt(Object, long) 
17.      */  
18.     public native long objectFieldOffset(Field f);  

[java] view plaincopy

1. private volatile int value;  
2.   
3. /** 
4.  * Creates a new AtomicInteger with the given initial value. 
5.  * 
6.  * @param initialValue the initial value 
7.  */  
8. public AtomicInteger(int initialValue) {  
9.     value = initialValue;  
10. }  
11.   
12. /** 
13.  * Creates a new AtomicInteger with initial value {@code 0}. 
14.  */  
15. public AtomicInteger() {  
16. }  

我们再回到CAS，看看getAndIncrement()方法是怎么利用CAS实现的。

[java] view plaincopy

1. /** 
2.     * Atomically increments by one the current value. 
3.     * 
4.     * @return the previous value 
5.     */  
6.    public final int getAndIncrement() {  
7.        return unsafe.getAndAddInt(this, valueOffset, 1);  
8.    }  

继续：

[java] view plaincopy

1. public final int getAndAddInt(Object o, long offset, int delta) {  
2.         int v;  
3.         do {  
4.             v = getIntVolatile(o, offset);//------------0---------------  
5.         } while (!compareAndSwapInt(o, offset, v, v + delta));//-------------1-------------  
6.         return v;  
7.     }  

[java] view plaincopy

1. /** 
2.    * Atomically update Java variable to <tt>x</tt> if it is currently 
3.    * holding <tt>expected</tt>. 
4.    * @return <tt>true</tt> if successful 
5.    */  
6.   public final native boolean compareAndSwapInt(Object o, long offset,//---------------2--------------  
7.                                                 int expected,  
8.                                                 int x);  

while(!compareAndSwapInt(o, offset, 0, 1))我们知道offset指向的地址对应的值就是原始变量的初值0，所以与期望的值0相同，所以将初值赋值为1，返回true，取反后为false，循环结束，返回v即更新之前的值0. 这就是类似于i++操作的原子操作的实现，当然最终CAS的实现都是native的，用C语言实现的，我们这里看不到源码，有时间我会反编译一下这段代码看看。

CAS线程安全

说了半天，我们要回归到最原始的问题了：这样怎么实现线程安全呢？请大家自己先考虑一下这个问题，其实我们在语言层面是没有做任何同步的操作的，大家也可以看到源码没有任何锁加在上面，可它为什么是线程安全的呢？这就是Atomic包下这些类的奥秘：语言层面不做处理，我们将其交给硬件—CPU和内存，利用CPU的多处理能力，实现硬件层面的阻塞，再加上volatile变量的特性即可实现基于原子操作的线程安全。所以说，CAS并不是无阻塞，只是阻塞并非在语言、线程方面，而是在硬件层面，所以无疑这样的操作会更快更高效！

总结

虽然基于CAS的线程安全机制很好很高效，但要说的是，并非所有线程安全都可以用这样的方法来实现，这只适合一些粒度比较小，型如计数器这样的需求用起来才有效，否则也不会有锁的存在了。

Atomic包实现原理

标签：java   atomic   atomicinteger   

原文地址：http://blog.csdn.net/li295214001/article/details/47171321