java volatile应用之 AtomicInteger

通过前一篇文章《Java Volatile》我们知道，volatile修饰的变量，线程不进行缓存，而是直接访问，但是要想保证多线程访问该变量时，线程安全，只有满足条件：操作是原子；

上篇中的i++，就是例子，他不是一个原子操作，所以不能保证多线程同时访问变量时，值的正确性；

本篇文章主要介绍 AtomicInteger的提供的访问方法和为什么它没有使用synchronized关键字也能保证多线程安全；

1 AtomicInteger常用方法

int get()void set(int newValue)int getAndSet(int newValue)int getAndIncrement()int getAndDecrement()int setAndGet(int newValue)int incrementAndGet()int decrementAndGet()

2 为什么AtomicInteger能保证多线程访问安全？

首先看看它的源代码：

public class AtomicInteger extends Number implements java.io.Serializable {    private static final long serialVersionUID = 6214790243416807050L;    // setup to use Unsafe.compareAndSwapInt for updates    private static final Unsafe unsafe = Unsafe.getUnsafe();    private static final long valueOffset;    static {      try {        valueOffset = unsafe.objectFieldOffset            (AtomicInteger.class.getDeclaredField("value"));      } catch (Exception ex) { throw new Error(ex); }    }    private volatile int value;    /**     * 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() {    }    /**     * Gets the current value.     *     * @return the current value     */    public final int get() {        return value;    }    /**     * Sets to the given value.     *     * @param newValue the new value     */    public final void set(int newValue) {        value = newValue;    }    /**     * Eventually sets to the given value.     *     * @param newValue the new value     * @since 1.6     */    public final void lazySet(int newValue) {        unsafe.putOrderedInt(this, valueOffset, newValue);    }    /**     * Atomically sets to the given value and returns the old value.     *     * @param newValue the new value     * @return the previous value     */    public final int getAndSet(int newValue) {        for (;;) {            int current = get();            if (compareAndSet(current, newValue))                return current;        }    }    /**     * Atomically sets the value to the given updated value     * if the current value {@code ==} the expected value.     *     * @param expect the expected value     * @param update the new value     * @return true if successful. False return indicates that     * the actual value was not equal to the expected value.     */    public final boolean compareAndSet(int expect, int update) {        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);    }    /**     * Atomically sets the value to the given updated value     * if the current value {@code ==} the expected value.     *     * <p>May <a href="package-summary.html#Spurious">fail spuriously</a>     * and does not provide ordering guarantees, so is only rarely an     * appropriate alternative to {@code compareAndSet}.     *     * @param expect the expected value     * @param update the new value     * @return true if successful.     */    public final boolean weakCompareAndSet(int expect, int update) {        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);    }    /**     * Atomically increments by one the current value.     *     * @return the previous value     */    public final int getAndIncrement() {        for (;;) {            int current = get();            int next = current + 1;            if (compareAndSet(current, next))                return current;        }    }    /**     * Atomically decrements by one the current value.     *     * @return the previous value     */    public final int getAndDecrement() {        for (;;) {            int current = get();            int next = current - 1;            if (compareAndSet(current, next))                return current;        }    }    /**     * Atomically adds the given value to the current value.     *     * @param delta the value to add     * @return the previous value     */    public final int getAndAdd(int delta) {        for (;;) {            int current = get();            int next = current + delta;            if (compareAndSet(current, next))                return current;        }    }    /**     * Atomically increments by one the current value.     *     * @return the updated value     */    public final int incrementAndGet() {        for (;;) {            int current = get();            int next = current + 1;            if (compareAndSet(current, next))                return next;        }    }    /**     * Atomically decrements by one the current value.     *     * @return the updated value     */    public final int decrementAndGet() {        for (;;) {            int current = get();            int next = current - 1;            if (compareAndSet(current, next))                return next;        }    }    /**     * Atomically adds the given value to the current value.     *     * @param delta the value to add     * @return the updated value     */    public final int addAndGet(int delta) {        for (;;) {            int current = get();            int next = current + delta;            if (compareAndSet(current, next))                return next;        }    }    /**     * Returns the String representation of the current value.     * @return the String representation of the current value.     */    public String toString() {        return Integer.toString(get());    }    public int intValue() {        return get();    }    public long longValue() {        return (long)get();    }    public float floatValue() {        return (float)get();    }    public double doubleValue() {        return (double)get();    }}

从上面源代码可知，对于计数变量value使用了volatile关键字，就是说线程在访问value时不缓存相应的值，而是直接访问堆中value的值，但是怎样保证修改它的值的操作是原子性的操作呢，看看函数 getAndIncrement()就知道了。

 /**     * Atomically increments by one the current value.     *     * @return the previous value     */    public final int getAndIncrement() {        for (;;) {            int current = get();            int next = current + 1;            if (compareAndSet(current, next))                return current;        }    }

• current = get(); 获取变量value的值，该步骤是原子性的，安全；
• 在线程中加1，存储到临时变量next中，不修改原始值，安全；
• compareAndSet(current, next) 这步就是最关键的一步，比较value的值是否和上一次取得的current值是否相等，相等就赋值，不相当就返回，循环；

compareAndSet(current, next) 调用了Unsafe类的compareAndSet方法来实现，它通过native c++方法来实现了底层操作的原子性，所以能保证多线程安全；

对于 sun.misc.Unsafe的具体分析和源码，见下面：

什么是Compare And Swap(CAS)？简单的说就是比较并交换。

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。” Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作。

在看一下volatile, Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的值是相同的，更简单一点理解就是volatile修饰的变量值发生变化时对于另外的线程是可见的。

如何正确使用volatile可以参考下面这篇文章：

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html Java 理论与实践: 正确使用 Volatile 变量

下面来看看java中具体的CAS操作类sun.misc.Unsafe。Unsafe类提供了硬件级别的原子操作，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。具体实现使用c++,详见文件sun.misc.natUnsafe.cc();sun.misc包的源代码可以在这里找到：

 http://www.oschina.net/code/explore/gcc-4.5.2/libjava/sun/misc