zoukankan      html  css  js  c++  java
  • 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);
        }
    

    返回顶部

  • 相关阅读:
    CentOS /RHEL系统怎么更新安全补丁
    使用yum查询系统安装的软件及可以更新的软件并单独指定升级某一个软件
    惠普服务器通过ILO系统远程安装系统
    django进行数据库迁移的错误处理方法:You are trying to change the nullable field 'title' on book to non-nullable without a d
    Django数据库增删改查
    linux用户
    linux基础
    mysql小白系列_01 原理
    mysql运维入门6:MySQL读写分离
    mysql运维入门5:MySQL+kepalived高可用架构
  • 原文地址:https://www.cnblogs.com/yanhui007/p/12586424.html
Copyright © 2011-2022 走看看