AtomicIntegerFieldUpdater

「爱情、让人受尽委屈。」 2022-09-11 06:13 34阅读 0赞

如果一个类是自己编写的，则可以在编写的时候把成员变量定义为Atomic类型。但如果是一个已经有的类，在不能更改其源代码的情况下，要想实现对其成员变量的原子操作，就需要AtomicIntegerFieldUpdater、AtomicLongFieldUpdater 和 AtomicReferenceFieldUpdater。

AtomicIntegerFieldUpdater的使用

public static void main(String[] args) {
        
            Student student = new Student();
            //创建AtomicIntegerFieldUpdater对象
            AtomicIntegerFieldUpdater<Student> studentAtomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Student.class, "age");
            //打印age并将age+1
            System.out.println(studentAtomicIntegerFieldUpdater.getAndIncrement(student));
            System.out.println(student.age);
        }
    //测试类   
    public class Student {
        
    	//因为是用反射实现的这里必须要使用public修饰
        public volatile int  age;
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }

要修改的age必须是int不能是包装类Integer,必须被volatile修饰

![在这里插入图片描述][8557b18205b74d748d5cbff039b3fc44.png]  
AtomicIntegerFieldUpdater代码实现

//AtomicIntegerFieldUpdater的无参构造被protected修饰,使用newUpdater创建对象
        protected AtomicIntegerFieldUpdater() {
        
        }
    
        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 {
        
                	//反射获得属性，这里是student的age
                    field = AccessController.doPrivileged(
                        new PrivilegedExceptionAction<Field>() {
        
                            public Field run() throws NoSuchFieldException {
        
                                return tclass.getDeclaredField(fieldName);
                            }
                        });
                    //判断age是不是public
                    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);
                }
    			//判断是不是int类型
                if (field.getType() != 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) &&
                               tclass.isAssignableFrom(caller) &&
                               !isSamePackage(tclass, caller))
                              ? caller : tclass;
                //目标类
                this.tclass = tclass;
                //Unsafe类获得age属性的偏移量
                this.offset = U.objectFieldOffset(field);
            }

getAndIncrement方法

public final int getAndIncrement(T obj) {
        
            	//age+1
                return getAndAdd(obj, 1);
            }
    
            public final int getAndAdd(T obj, int delta) {
        
            	//检查obj和声明AtomicIntegerFieldUpdater时的class一不一样
                accessCheck(obj);
                //Unsafe类获得age的值并且使用compareAndSwapInt将age+1
                return U.getAndAddInt(obj, offset, delta);
            }

AtomicLongFieldUpdater 和 AtomicReferenceFieldUpdater和AtomicIntegerFieldUpdater类似

[8557b18205b74d748d5cbff039b3fc44.png]: /images/20220828/a0c1c1665c0f4ad8b0fcf6e112ef56ff.png