Atomic类和CAS

来源：互联网发布：视频合并软件绿色版编辑：程序博客网时间：2024/05/21 11:07

说Atomic类之前，先聊一聊volatile。

对volatile的第一印象就是可见性。所谓可见性，就是一个线程对共享变量的修改，别的线程能够感知到。

但是对于原子性，volatile是不能保证的。来看看自增操作的问题：

volatile int i;i++;

i++ 在多线程环境下，是不能保证最终的结果正确的。比如某个时刻，i=5，线程A读取了i的值，说时迟那时快，就在马上要执行++操作时，线程A突然就被切换走了；然后线程B也读取i的值，进行了++操作。这时i的值是6，即使线程A的工作内存中的缓存已经失效，线程A已经读取了i的值为5，不会再去读取，所以++操作后，i的值还是6。

关于volatile的底层实现，有好多文章分析的很透彻，这里不再赘述。

那么除了使用synchronized，还有没有其它的方式来解决上述问题呢？天空一声巨响，Atomic类闪亮登场！！！

先看看AtomicInteger类，其它类型包装成的Atomic类，请读者自习。

AtomicInteger i = new AtomicInteger(0);i.incrementAndGet();

用法相当简单，incrementAndGet 方法能实现原子性的自增操作。如何实现，看源码。

    /**     * Atomically increments by one the current value.     *     * @return the updated value     */    public final int incrementAndGet() {        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;    }

Unsafe类：

    /**     * Atomically adds the given value to the current value of a field     * or array element within the given object <code>o</code>     * at the given <code>offset</code>.     *     * @param o object/array to update the field/element in     * @param offset field/element offset     * @param delta the value to add     * @return the previous value     * @since 1.8     */    public final int getAndAddInt(Object o, long offset, int delta) {        int v;        do {            v = getIntVolatile(o, offset);        } while (!compareAndSwapInt(o, offset, v, v + delta));        return v;    }

/**     * Atomically update Java variable to <tt>x</tt> if it is currently     * holding <tt>expected</tt>.     * @return <tt>true</tt> if successful     */    public final native boolean compareAndSwapInt(Object o, long offset,                                                  int expected,                                                  int x);

可以看到原子性的实现没有用synchronized，说明是非阻塞同步。最核心的方法是compareAndSwapInt，也就是所谓的CAS操作。

CAS操作依赖底层硬件的CAS指令，CAS指令有两个步骤：冲突检测和更新操作，但是这两个步骤合起来成为一个原子性操作。

CAS指令需要3个操作数：内存位置（V），旧的预期值（A），新值（B）。CAS指令执行时，首先比较内存位置V处的值和A的值是否相等（冲突检测），如果相等，就用新值B覆盖A（更新操作），否则，就什么也不做。所以，一般循环执行CAS操作，直到成功为止。

Unsafe类里面的compareAndSwapXXX 方法最后都会变成与硬件相关的CAS指令。从Unsafe这个类名就可以看出，作者不希望我们随便使用，因为是不安全的。为什么不安全呢，因为这个类可以直接操作内存；还有其他的一些底层操作，比如上篇文章提到的将线程挂起，就是调用了Unsafe类的park方法（感兴趣的，出门左拐）。

了解了CAS和Unsafe类，接着再说AtomicInteger类：

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

value就是我们需要操作的真正int值，unsafe就是Unsafe类的单例，valueOffset在static语句块里面，被设置成了value变量在AtomicInteger类的实例对象里面的偏移量（可以看成内存地址）。这里对对象的内存布局如有疑问，同样出门一路左拐，找到那篇将Oop和Klass的文章。

也就是说，Atomic类通过循环进行CAS操作，直到成功，来实现非阻塞同步，进而变成原子操作。

在java.util.concurrent.atomic包下还有一些看上去比较奇怪的类，XXXFieldUpdater类，这玩意儿是用来干什么的呢？

一句话概括，就是亡羊补牢。比如说，你先自己写了一个类，定义了一个基础类型的变量。后来涉及到多线程，那么原来对该变量的一些操作就变得不安全。如果，你立马想到的是手动修改代码，那就太low了，破坏了设计模式里面比较重要的开闭原则，而且很多情况下，你是接触不到别人的源代码的。这个时候，XXXFieldUpdater类就派上用场了。这个时候，猜也能猜到，这个类肯定是通过反射的方式实现这个功能的。另外，有一点原来定义的继承类型变量，必须是volatile的。

直接上代码，看效果：

public class Test{    public volatile int a = 100;        // 多线程下不安全    public void incr() {        a++;    }  }

public class SafeTest{    private static AtomicIntegerFieldUpdater<Test> update = AtomicIntegerFieldUpdater.newUpdater(Test.class, "a");    private static Test test = new Test();    // 多线程下安全    public void incr() {       update.incrementAndGet(test);    }}

update.incrementAndGet(test)无非也是调用了Unsafe类的CAS操作，核心方法是AtomicIntegerFieldUpdater.newUpdater(Test.class, "a")，看看源码：

    @CallerSensitive    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,                                                              String fieldName) {        return new AtomicIntegerFieldUpdaterImpl<U>            (tclass, fieldName, Reflection.getCallerClass());    }    AtomicIntegerFieldUpdaterImpl(final Class<T> tclass,                                      final String fieldName,                                      final Class<?> caller) {            // 反射逻辑            final Field field;            final int modifiers;            try {                field = AccessController.doPrivileged(                    new PrivilegedExceptionAction<Field>() {                        public Field run() throws NoSuchFieldException {                            return tclass.getDeclaredField(fieldName);                        }                    });                modifiers = field.getModifiers();                sun.reflect.misc.ReflectUtil.ensureMemberAccess(                    caller, tclass, null, modifiers);                ClassLoader cl = tclass.getClassLoader();                ClassLoader ccl = caller.getClassLoader();                if ((ccl != null) && (ccl != cl) &&                    ((cl == null) || !isAncestor(cl, ccl))) {                  sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);                }            } catch (PrivilegedActionException pae) {                throw new RuntimeException(pae.getException());            } catch (Exception ex) {                throw new RuntimeException(ex);            }            Class<?> fieldt = field.getType();            if (fieldt != int.class)                throw new IllegalArgumentException("Must be integer type");            // 必须是volatile            if (!Modifier.isVolatile(modifiers))                throw new IllegalArgumentException("Must be volatile type");            this.cclass = (Modifier.isProtected(modifiers) &&                           caller != tclass) ? caller : null;            this.tclass = tclass;            // 得到变量的偏移量，相当于内存地址            offset = unsafe.objectFieldOffset(field);        }

总的来说，原子性的实现是依赖于Unsafe类的CAS操作，直接修改内存里的值，既危险又刺激。我们甚至可以用Unsafe类来直接分配内存，要不试一试！！！

Unsafe类是单例，可以通过它的getUnsafe方法获取这个单例。

    @CallerSensitive    public static Unsafe getUnsafe() {        Class<?> caller = Reflection.getCallerClass();        // 调用方的类的类加载器必须是启动类加载器        if (!VM.isSystemDomainLoader(caller.getClassLoader()))            throw new SecurityException("Unsafe");        return theUnsafe;    }

这个方法对调用方有限制，就是说你随随便便定义的类，调用这个方法是会报错的。但是Unsafe类既然已经被加载，我们可以通过反射的方式去获取里面的单例对象。

package test;import java.lang.reflect.Field;import sun.misc.Unsafe;import sun.reflect.Reflection;class User {    private String name = "";    private int age = 0;    public User() {        this.name = "test";        this.age = 25;    }        @Override    public String toString() {        return name + ": " + age;    }}public class Test {    public static void main(String[] args) throws NoSuchFieldException,            SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {        // 通过反射得到theUnsafe对应的Field对象        Field field = Unsafe.class.getDeclaredField("theUnsafe");        // 设置该Field为可访问        field.setAccessible(true);        // 通过Field得到该Field对应的具体对象，传入null是因为该Field为static的        Unsafe unsafe = (Unsafe) field.get(null);        // 直接分配相应大小的内存，不执行构造方法        User user = (User) unsafe.allocateInstance(User.class);        System.out.println(user);                User userFromNormal = new User();        System.out.println(userFromNormal);    }}

这个例子演示了Unsafe直接为某个类的实例分配内存，注意是只分配内存，没有顺便调用构造方法。

运行结果：

null: 0test: 25

当然，Unsafe类里面还有好多的底层操作，宝藏后面慢慢挖掘。就到这里吧！！！

阅读全文

0 0