FieldUpdater

FieldUpdater

一般我们在多线程环境下，更新一个对象的字段，我们会对操作对象的方法进行加锁，让线程串行，从而达到线程安全的目的。但加锁不当，可能使程序性能不佳，或者引起死锁问题。如果不加锁，那么可以使用FieldUpdater 进行操作字段，也能够达到线程安全的目的。

FieldUpdater 在java.util.concurrent.atomic包中，由三个比较特殊的原子类：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater。
通过名称可以看到，这几类的功能大致相同，只是针对的类型有所不同。所谓AtomicXXXFieldUpdater，就是可以以一种线程安全的方式操作非线程安全对象的某些字段。

AtomicReferenceFieldUpdater

AtomicReferenceFieldUpdater 使用

AtomicReferenceFieldUpdater本身是一个抽象类，没有公开的构造器，只能通过静态方法newUpdater创建一个AtomicReferenceFieldUpdater子类对象：

newUpdater有三个入参

入参名称	含义
tclass	目标对象的类型
vclass	目标字段的类型
fieldName	目标字段名

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

        AtomicReferenceFieldUpdaterImpl(final Class<T> tclass,
                                        final Class<V> vclass,
                                        final String fieldName,
                                        final Class<?> caller) {
            final Field field;
            final Class<?> fieldClass;
            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);
                }
                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))
                // 必须用volatile修饰
                throw new IllegalArgumentException("Must be volatile type");

            // Access to protected field members is restricted to receivers only
            // of the accessing class, or one of its subclasses, and the
            // accessing class must in turn be a subclass (or package sibling)
            // of the protected member's defining class.
            // If the updater refers to a protected field of a declaring class
            // outside the current package, the receiver argument will be
            // narrowed to the type of the accessing class.
            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**的使用条件

1. AtomicReferenceFieldUpdater只能修改对于它可见的字段，也就是说对于目标类的某个字段field，如果修饰符是private，但是AtomicReferenceFieldUpdater所在的使用类不能看到field，那就会报错；
2. 目标类的操作字段，必须用volatile修饰；
3. 目标类的操作字段，不能是static的；
4. AtomicReferenceFieldUpdater只适用于引用类型的字段；

AtomicReferenceFieldUpdater的方法原理

AtomicReferenceFieldUpdater中所有的方法都是基于Unsafe类操作,通过偏移量offset获取字段的地址，然后利用Unsafe进行CAS更新

        public final boolean compareAndSet(T obj, V expect, V update) {
            accessCheck(obj);
            valueCheck(update);
            return U.compareAndSwapObject(obj, offset, expect, update);
        }

AtomicReferenceFieldUpdater 案例

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

public class TestAtomicReferenceFieldUpdater {

    public static void main(String[] args) {
        AtomicReferenceFieldUpdater updater= AtomicReferenceFieldUpdater.newUpdater(Person .class, String.class, "name");
        Person person = new Person();
        // 如果 person 的name 属性是 jim  那么更新 name 为marry
        boolean b = updater.compareAndSet(person, "jim", "marry");
        System.out.println(b); // true 
        System.out.println(person.name); // marry
        // 获取 name 的值
        Object o = updater.get(person); 
        System.out.println(o); // marry

        // 如果 person 的name 属性是 jim  那么更新 name 为marry，此时的name 是marry,所以更新会失败
        boolean c = updater.compareAndSet(person, "jim", "tom");
        System.out.println(c); // false
        System.out.println(person.name); // marry
    }
}

class Person{
    volatile String name = "jim";
}

输出结果

true
marry
marry
false
marry

AtomicIntegerFieldUpdater

AtomicIntegerFieldUpdater

AtomicIntegerFieldUpdater 的newUpdater 方法和AtomicReferenceFieldUpdater 类似，只不过AtomicIntegerFieldUpdater处理的是int 类型的所以少一个字段类型参数，

newUpdater有三个入参

入参名称	含义
tclass	目标对象的类型
fieldName	目标字段名

    public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass,
                                                              String fieldName) {
        return new AtomicIntegerFieldUpdaterImpl<U>
            (tclass, fieldName, Reflection.getCallerClass());
    }

AtomicIntegerFieldUpdater的使用条件

1. AtomicIntegerFieldUpdater只能修改对于它可见的字段，也就是说对于目标类的某个字段field，如果修饰符是private，但是AtomicIntegerFieldUpdater所在的使用类不能看到field，那就会报错；
2. 目标类的操作字段，必须用volatile修饰；
3. 目标类的操作字段，不能是static的；
4. AtomicIntegerFieldUpdater只适用于int类型的字段；

AtomicIntegerFieldUpdater案例

假设有一个公司账户Account，100个人同时往里面存钱1块钱，那么正常情况下，最终账户的总金额应该是100。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

/**
 * @author Jim Huang
 * @date 2021/5/27 10:48
 */
public class TestAtomicIntegerFieldUpdater {
    public static void main(String[] args) throws Exception{
        Account account = new Account(0);

        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Thread t = new Thread(new Task(account));
            list.add(t);
            t.start();
        }

        for (Thread t : list) {
            t.join();
        }

        System.out.println(account.toString());
    }

   static class Account {
        private volatile int money;
        private static final AtomicIntegerFieldUpdater<Account> updater = AtomicIntegerFieldUpdater.newUpdater(Account.class, "money");  // 引入AtomicIntegerFieldUpdater

        Account(int initial) {
            this.money = initial;
        }

        public void increMoney() {
            updater.incrementAndGet(this);    // 通过AtomicIntegerFieldUpdater操作字段
        }

        public int getMoney() {
            return money;
        }

        @Override
        public String toString() {
            return "Account{" +
                    "money=" + money +
                    '}';
        }
    }

    private static class Task implements Runnable {
        private Account account;

        Task(Account account) {
            this.account = account;
        }

        @Override
        public void run() {
            account.increMoney();
        }
    }
}

执行结果

Account{money=100}