java.util.concurrent源码阅读 02 关于java.util.concurrent.atomic包

Aomic包下有四种数据类型：AomicBoolean, AomicInteger, AomicLong和AomicReferrence(针对Object的)以及它们的数组类型, 和相对应的AtomicXXXFieldUpdater.
各种数据类型中所有的原子操作都依赖于sun.misc.Unsafe这个类和CAS操作.

sun.misc.Unsafe

Java是一个安全的开发工具, 大部分的底层操作全部封装在JNI中, 阻止开发人员犯很多低级的错误. 但是jdk依然提供了Unsafe类, 用于操作内存. 事实上, jdk是禁止直接构建Unsafe实例的, Unsafe.getUnsafe()只允许被JDK信任的类调用, 如果直接调用会抛出SecutiryException.(进一步了解https://dzone.com/articles/understanding-sunmiscunsafe.)

CAS

现代主流CPU都支持的一种硬件级别的原子操作, 比较并交换, 操作包含三个操作数:

内存位置(V)
预期原值(A)
新值(B)

如果内存位置的值与预期原值相匹配, 那么处理器会自动将该位置值更新为新值,否则, 处理器不做任何操作.无论哪种情况, 它都会在 CAS 指令之前返回该位置的值.

优点: 效率高, 无锁

AtomicXXXX四种数值类型

1. value成员都是volatile:
   保证写volatile变量会强制把CPU写缓存区的数据刷新到内存;
   读volatile变量时，使缓存失效，强制从内存中读取最新的值.
2. 基本方法get/set
3. 主要方法:
   compareAndSet,
   weakCompareAndSet,
   lazySet,
   getAndSet: 取当前值, 使用当前值和准备更新的值做CAS.
4. 对于Long和Integer
   getAndIncrement/incrementAndGet,
   getAndDecrement/decrementAndGet,
   getAndAdd/addAndGet.
   三组方法都和getAndSet，取当前值，加减之得到准备更新的值，再做CAS，/左右的区别在于返回的是当前值还是更新值.

以AtomicInteger为例详细说明

1.成员变量

// setup to use Unsafe.compareAndSwapInt for updates
//如前所述, 用于直接操作内存的类
private static final Unsafe unsafe = Unsafe.getUnsafe();
//内存中,成员变量的地址相对于对象的偏移量
private static final long valueOffset;

//利用unsafe计算偏移量valueOffset
static {
     try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
      } catch (Exception ex) { throw new Error(ex); }
}

//存储int值
//volatile保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 
//当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.
private volatile int value;

2.构造函数

/**
 * 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() {
}

3.get/set

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

4.主要方法

/**
 * Eventually sets to the given value.
 * @param newValue the new value
 * @since 1.6
 */
//putOrderedXXX方法是putXXXVolatile方法的延迟实现，不保证值的改变被其他线程立即看到.
//volatile变量的修改可以立刻让所有的线程可见,lazySet说白了就是以普通变量的方式来写变量
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.
 *
 * 
May fail spuriously
 * 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();
}