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;
    }