Package java.util.concurrent.atomic
这是一个小工具包，它的实际作用是提供了很多个无阻塞的线程安全的变量操作工具。
无阻塞的线程安全：其含义就是不使用 synchronize，而使用 volatile+CAS 的方式实现。
该包下类摘要
挑一个 AtomicInteger 来分析一下吧，比较典型。
package java.util.concurrent.atomic;import java.util.function.IntUnaryOperator;import java.util.function.IntBinaryOperator;import sun.misc.Unsafe;
/** * 原子性地更新int类型地值。 * java.util.concurrent.atomic * AtomicInteger 常用于原子地计数器中，并且不能用于替代Integer。 */public class AtomicInteger extends Number implements java.io.Serializable { private static final long serialVersionUID = 6214790243416807050L;
// 设置使用Unsafe.compareAndSwapInt来进行更新, cas操作 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); } }
// 存放值的地方, 用了volatile修饰 private volatile int value;
/** * 创建一个给定初始值的AtomicInteger对象 */ public AtomicInteger(int initialValue) { value = initialValue; }
/** * 创建一个初始值为0的AtomicInteger对象 */ public AtomicInteger() { }
/** * 获取当前的值, 这里也没有加锁 * 只要别人update了, volatile一定会让你看到 */ public final int get() { return value; }
/** * 设定新的值, 看看这里也没有加锁 * 只要别人update了, volatile一定会让你看到 */ public final void set(int newValue) { value = newValue; }
/** * 最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值。 */ public final void lazySet(int newValue) { unsafe.putOrderedInt(this, valueOffset, newValue); }
/** * 原子的设置为给定的值, 并返回旧的值 */ public final int getAndSet(int newValue) { return unsafe.getAndSetInt(this, valueOffset, newValue); }
/** * 如果输入的数值等于预期值，则以原子方式将该值设置为输入的值。 * 成功则返回相等，否则期望值和实际值的值不一样 */ public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
/** * 这个不知道干啥的 */ public final boolean weakCompareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
/** * 以原子方式将当前值加1，注意：这里返回的是自增前的值。 */ public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); }
/** * 以原子方式将当前值减1，注意：这里返回的是自增前的值。 */ public final int getAndDecrement() { return unsafe.getAndAddInt(this, valueOffset, -1); }
/** * 以原子方式将当前值加上给定的值，注意：这里返回的是自增前的值。 */ public final int getAndAdd(int delta) { return unsafe.getAndAddInt(this, valueOffset, delta); }
/** * 以原子方式将当前值加1，注意：这里返回的是增加后的值。 */ public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; }
/** * 以原子方式将当前值减1，注意：这里返回的是减少后的值。 */ public final int decrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, -1) - 1; }
/** * 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加 * 并返回更新后的结果 */ public final int addAndGet(int delta) { return unsafe.getAndAddInt(this, valueOffset, delta) + delta; }
/** * 开放了一个接口，你爱干啥干啥，反正我返回之前的值 */ public final int getAndUpdate(IntUnaryOperator updateFunction) { int prev, next; do { prev = get(); next = updateFunction.applyAsInt(prev); } while (!compareAndSet(prev, next)); return prev; }
/** * 你爱干啥干啥，反正我返回修改之后的值 */ public final int updateAndGet(IntUnaryOperator updateFunction) { int prev, next; do { prev = get(); next = updateFunction.applyAsInt(prev); } while (!compareAndSet(prev, next)); return next; }
/** * 你爱干啥干啥 */ public final int getAndAccumulate(int x, IntBinaryOperator accumulatorFunction) { int prev, next; do { prev = get(); next = accumulatorFunction.applyAsInt(prev, x); } while (!compareAndSet(prev, next)); return prev; }
/** * 你爱干啥干啥 */ public final int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction) { int prev, next; do { prev = get(); next = accumulatorFunction.applyAsInt(prev, x); } while (!compareAndSet(prev, next)); return next; }
/** * 返回当前值的字符串表示 */ 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(); }
}大部分都还是看得懂的，但是有几个方法是有疑惑的：
public final boolean weakCompareAndSet(int expect, int update);
public final void lazySet(int newValue);
这两个是干啥用的？
下面该看一下 Unsafe 的工作原理了。