concurrent-原子类

1. 基本类型: AtomicInteger, AtomicLong, AtomicBoolean ;
2. 数组类型: AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray ;
3. 引用类型: AtomicReference, AtomicStampedRerence, AtomicMarkableReference ;
4. 对象的属性修改类型: AtomicIntegerFieldUpdater, AtomicLongFieldUpdater, AtomicReferenceFieldUpdater 。
   

AtomicInteger

底层通过unsafe实现的cas：

    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

    public final int getAndSetInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));

        return var5;
    }

返回顶部

AtomicReferenceFieldUpdater

使用示例：

class Person{
    public volatile String name = "z1";//注意这个字段是volatile类型 并且是public的
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

public static void main(String[] args) {
        AtomicReferenceFieldUpdater updater = AtomicReferenceFieldUpdater.newUpdater(Person.class, String.class, "name");
        Person person = new Person();
        updater.compareAndSet(person,person.getName(),"l2");
        System.out.println(person.getName());
    }

源码：
AtomicReferenceFieldUpdater.newUpdater：

@CallerSensitive
    public static <U,W> AtomicReferenceFieldUpdater<U,W> newUpdater(Class<U> tclass,
                                                                    Class<W> vclass,
                                                                    String fieldName) {
        return new AtomicReferenceFieldUpdater.AtomicReferenceFieldUpdaterImpl<U,W>
                (tclass, vclass, fieldName, Reflection.getCallerClass());
    }

    AtomicReferenceFieldUpdaterImpl(final Class<T> tclass,//类class
                                    final Class<V> vclass,//字段类型class
                                    final String fieldName,//字段名称
                                    final Class<?> caller) {
        final Field field;
        final Class<?> fieldClass;
        final int modifiers;
        try {
            //获取待更新field
            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);
            }
            fieldClass = field.getType();
        } catch (PrivilegedActionException pae) {
            throw new RuntimeException(pae.getException());
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }

        if (vclass != fieldClass)
            throw new ClassCastException();
        if (vclass.isPrimitive())
            throw new IllegalArgumentException("Must be reference type");

        if (!Modifier.isVolatile(modifiers))
            throw new IllegalArgumentException("Must be volatile type");

        this.cclass = (Modifier.isProtected(modifiers) &&
                tclass.isAssignableFrom(caller) &&
                !isSamePackage(tclass, caller))
                ? caller : tclass;
        this.tclass = tclass;
        this.vclass = vclass;
        this.offset = U.objectFieldOffset(field);
    }

AtomicReferenceFieldUpdater.compareAndSet：底层通过Unsafe cas实现原子更新

    public boolean compareAndSet(U obj, M expect, M update) {
        return this.unsafe.compareAndSwapObject(obj, this.offset, expect, update);
    }

返回顶部