juc的Atomic

Java从JDK1.5开始提供java.util.concurrent.atomic包，方便程序员在多线程环境下，无锁的进行原子操作。 原子变量的底层使用了处理器提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁，所以该方法不能绝对保证线程不被阻塞。atomic使用的是cas的更新方式，当某个线程在执行atomic的方法时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个线程执行，在软件层面上是非阻塞的，它是在底层硬件上借助处理器的原子指令来保证的。 Atomic包里一共有12个类，四种原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用、原子更新字段。Atomic包里的类基本都是使用Unsafe实现的包装类。

AtomicBoolean，AtomicInteger，AtomicLong，AtomicReferenceAtomicIntegerArray，AtomicLongArray，AtomicReferenceArrayAtomicLongFieldUpdate，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdaterAtomicMarkableReference，AtomicStapedReference 我们看一下最简单的AtomicInteger有哪些常用的方法： 方法作用get()直接返回值getAndAdd(int)增加指定的数据，返回变化前的数据getAndDecrement()减少1，返回减少前的数据getAndIncrement()增加1，返回增加前的数据getAndSet(int)设置指定的数据，返回设置前的数据addAndGet(int)增加指定的数据，返回变化后的数据decrementAndGet()减少1，返回变化后的值incrementAndGet()增加1，返回变化后的值lazeSet(int)仅仅当get时才会set，参考：lazySet是如何工作的compareAndSet(int,int)尝试新增后对比，若增加成功则返回true，失败返回false

我们看一下Unsafe的源码：

package sun.misc; public final class Unsafe { ...... //可以看出所有方法都是native修饰的 public native int getInt(Object var1, long var2); public native void putInt(Object var1, long var2, int var4); public native Object getObject(Object var1, long var2); public native void putObject(Object var1, long var2, Object var4); //使用处理器提供的CAS算法去做更新 public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5); public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6); public final int getAndAddInt(Object var1, long var2, int var4) { int var5; //在这个地方做一个自旋，保证一定更新成功 do { //volatile保证可见性，每次都会从主内存中获取最新值 var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; } public final long getAndAddLong(Object var1, long var2, long var4) { long var6; do { var6 = this.getLongVolatile(var1, var2); } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4)); return var6; } ...... }

我们看一下Atomic的源码，可以看出是直接调用了Unsafe的方法（即JNI接口）

public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } public final int decrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, -1) - 1; }

Unsafe只提供了三种CAS方法，compareAndSwapObject，compareAndSwapInt和compareAndSwapLong，那么其他类型怎么更新呢？再看AtomicBoolean源码，发现是先把Boolean转换成整型，再使用compareAndSwapInt进行CAS，所以原子更新double也可以用类似的思路来实现。

//AtomicBoolean源码 public final boolean compareAndSet(boolean expect, boolean update) { int e = expect ? 1 : 0; int u = update ? 1 : 0; return unsafe.compareAndSwapInt(this, valueOffset, e, u); } //AtomicDouble源码 //PS:AtomicDouble不是juc.atomic包下的，是com.google.common.util.concurrent下的 public final double getAndSet(double newValue) { long next = Double.doubleToRawLongBits(newValue); return Double.longBitsToDouble(updater.getAndSet(this, next)); } public final boolean compareAndSet(double expect, double update) { return updater.compareAndSet(this, Double.doubleToRawLongBits(expect), Double.doubleToRawLongBits(update)); }

原子更新数组类 AtomicIntegerArray常用方法：

方法作用addAndGet()以原子方式将输入值与数组中的索引i的元素相加compareAndSet(int i,int exepect,int update)如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值 public final int addAndGet(int i, int delta) { return getAndAdd(i, delta) + delta; } public final int getAndAdd(int i, int delta) { return unsafe.getAndAddInt(array, checkedByteOffset(i), delta); } public final boolean compareAndSet(int i, int expect, int update) { return compareAndSetRaw(checkedByteOffset(i), expect, update); } private boolean compareAndSetRaw(long offset, int expect, int update) { return unsafe.compareAndSwapInt(array, offset, expect, update); }

AtomicIntegerArray类需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。 原子更新引用类型 原子更新基本类型AtomicInteger，只能更新一个变量，如果要原子的更新多个变量，就需要使用这个原子更新引用类型提供的类。

AtomicReference：原子更新引用类型。AtomicReferenceFieldUpdater：原子更新引用类型里的字段。AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子的更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference(V initialRef, boolean initialMark) AtomicMarkableReference源码如下，是使用了一个内部类Pair绑定更新标记为和引用的 public class AtomicMarkableReference<V> { private static class Pair<T> { final T reference; final boolean mark; private Pair(T reference, boolean mark) { this.reference = reference; this.mark = mark; } static <T> Pair<T> of(T reference, boolean mark) { return new Pair<T>(reference, mark); } } private volatile Pair<V> pair; public V get(boolean[] markHolder) { Pair<V> pair = this.pair; markHolder[0] = pair.mark; return pair.reference; } public boolean compareAndSet(V expectedReference, V newReference, boolean expectedMark, boolean newMark) { Pair<V> current = pair; return expectedReference == current.reference && expectedMark == current.mark && ((newReference == current.reference && newMark == current.mark) || casPair(current, Pair.of(newReference, newMark))); } //对Pair进行CAS private boolean casPair(Pair<V> cmp, Pair<V> val) { return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val); }

AtomicReference的使用例子代码如下：

public class AtomicReferenceTest { public static AtomicReference<user> atomicUserRef = new AtomicReference</user><user>(); public static void main(String[] args) { User user = new User("conan", 15); atomicUserRef.set(user); User updateUser = new User("Shinichi", 17); atomicUserRef.compareAndSet(user, updateUser); System.out.println(atomicUserRef.get().getName()); System.out.println(atomicUserRef.get().getAge()); } static class User { private String name; private int age; public User(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } }

原子更新字段 如果我们只需要更新某个类里的某个字段，那么就需要使用原子更新字段类。

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。AtomicLongFieldUpdater：原子更新长整型字段的更新器。AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。实现与AtomicMarkableReference类似，都是使用了Pair内部类实现版本号和数据的绑定CAS更新。 public abstract class AtomicIntegerFieldUpdater<T> { public abstract boolean compareAndSet(T obj, int expect, int update); public abstract void lazySet(T obj, int newValue); public abstract int get(T obj); public int getAndAdd(T obj, int delta) { int prev, next; do { prev = get(obj); next = prev + delta; } while (!compareAndSet(obj, prev, next)); return prev; }

原子更新字段类都是抽象类，每次使用都的时候都必须使用静态方法newUpdater创建一个更新器。原子更新类的字段必须使用public volatile修饰符。AtomicIntegerFieldUpdate的例子代码如下：

public class AtomicIntegerFieldUpdaterTest { private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater .newUpdater(User.class, "age"); public static void main(String[] args) { User conan = new User("conan", 10); System.out.println(a.getAndIncrement(conan)); System.out.println(a.get(conan)); } static class User { private String name; private int age; public User(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } }

参考文章：CAS：利用处理器原子性来保证juc.atomic原子性