Java concurrency之AtomicLongFieldUpdater原子类_动力节点Java学院整理

AtomicLongFieldUpdater介绍和函数列表

AtomicLongFieldUpdater可以对指定"类的 'volatile long'类型的成员"进行原子更新。它是基于反射原理实现的。

AtomicLongFieldUpdater函数列表

// 受保护的无操作构造方法，供子类使用。
protected AtomicLongFieldUpdater()
// 以原子方式将给定值添加到此更新器管理的给定对象的字段的当前值。
long addAndGet(T obj, long delta)
// 如果当前值 == 预期值，则以原子方式将此更新器所管理的给定对象的字段设置为给定的更新值。
abstract boolean compareAndSet(T obj, long expect, long update)
// 以原子方式将此更新器管理的给定对象字段当前值减 1。
long decrementAndGet(T obj)
// 获取此更新器管理的在给定对象的字段中保持的当前值。
abstract long get(T obj)
// 以原子方式将给定值添加到此更新器管理的给定对象的字段的当前值。
long getAndAdd(T obj, long delta)
// 以原子方式将此更新器管理的给定对象字段当前值减 1。
long getAndDecrement(T obj)
// 以原子方式将此更新器管理的给定对象字段的当前值加 1。
long getAndIncrement(T obj)
// 将此更新器管理的给定对象的字段以原子方式设置为给定值，并返回旧值。
long getAndSet(T obj, long newValue)
// 以原子方式将此更新器管理的给定对象字段当前值加 1。
long incrementAndGet(T obj)
// 最后将此更新器管理的给定对象的字段设置为给定更新值。
abstract void lazySet(T obj, long newValue)
// 为对象创建并返回一个具有给定字段的更新器。
static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName)
// 将此更新器管理的给定对象的字段设置为给定更新值。
abstract void set(T obj, long newValue)
// 如果当前值 == 预期值，则以原子方式将此更新器所管理的给定对象的字段设置为给定的更新值。
abstract boolean weakCompareAndSet(T obj, long expect, long update)

AtomicLongFieldUpdater示例

// LongTest.java的源码
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
public class LongFieldTest {
  public static void main(String[] args) {
    // 获取Person的class对象
    Class cls = Person.class; 
    // 新建AtomicLongFieldUpdater对象，传递参数是“class对象”和“long类型在类中对应的名称”
    AtomicLongFieldUpdater mAtoLong = AtomicLongFieldUpdater.newUpdater(cls, "id");
    Person person = new Person(12345678L);
    // 比较person的"id"属性，如果id的值为12345678L，则设置为1000。
    mAtoLong.compareAndSet(person, 12345678L, 1000);
    System.out.println("id="+person.getId());
  }
}
class Person {
  volatile long id;
  public Person(long id) {
    this.id = id;
  }
  public void setId(long id) {
    this.id = id;
  }
  public long getId() {
    return id;
  }
}

运行结果：

id=1000

AtomicLongFieldUpdater源码分析(基于JDK1.7.0_40)

AtomicLongFieldUpdater完整源码

 /*
  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  */
 /*
  *
  *
  *
  *
  *
  * Written by Doug Lea with assistance from members of JCP JSR-
  * Expert Group and released to the public domain, as explained at
  * http://creativecommons.org/publicdomain/zero/./
  */
 package java.util.concurrent.atomic;
 import java.lang.reflect.*;
 import sun.misc.Unsafe;
 import sun.reflect.CallerSensitive;
 import sun.reflect.Reflection;
 /**
  * A reflection-based utility that enables atomic updates to
  * designated {@code volatile} reference fields of designated
  * classes. This class is designed for use in atomic data structures
  * in which several reference fields of the same node are
  * independently subject to atomic updates. For example, a tree node
  * might be declared as
  *
  * <pre> {@code
  * class Node {
  *  private volatile Node left, right;
  *
  *  private static final AtomicReferenceFieldUpdater<Node, Node> leftUpdater =
  *   AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "left");
  *  private static AtomicReferenceFieldUpdater<Node, Node> rightUpdater =
  *   AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "right");
  *
  *  Node getLeft() { return left; }
  *  boolean compareAndSetLeft(Node expect, Node update) {
  *   return leftUpdater.compareAndSet(this, expect, update);
  *  }
  *  // ... and so on
  * }}</pre>
  *
  * <p>Note that the guarantees of the {@code compareAndSet}
  * method in this class are weaker than in other atomic classes.
  * Because this class cannot ensure that all uses of the field
  * are appropriate for purposes of atomic access, it can
  * guarantee atomicity only with respect to other invocations of
  * {@code compareAndSet} and {@code set} on the same updater.
  *
  * @since .
  * @author Doug Lea
  * @param <T> The type of the object holding the updatable field
  * @param <V> The type of the field
  */
 public abstract class AtomicReferenceFieldUpdater<T, V> {
   /**
    * Creates and returns an updater for objects with the given field.
    * The Class arguments are needed to check that reflective types and
    * generic types match.
    *
    * @param tclass the class of the objects holding the field.
    * @param vclass the class of the field
    * @param fieldName the name of the field to be updated.
    * @return the updater
    * @throws IllegalArgumentException if the field is not a volatile reference type.
    * @throws RuntimeException with a nested reflection-based
    * exception if the class does not hold field or is the wrong type.
    */
   @CallerSensitive
   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());
   }
   /**
   * Protected do-nothing constructor for use by subclasses.
   */
   protected AtomicReferenceFieldUpdater() {
   }
   /**
   * Atomically sets the field of the given object managed by this updater
   * to the given updated value if the current value {@code ==} the
   * expected value. This method is guaranteed to be atomic with respect to
   * other calls to {@code compareAndSet} and {@code set}, but not
   * necessarily with respect to other changes in the field.
   *
   * @param obj An object whose field to conditionally set
   * @param expect the expected value
   * @param update the new value
   * @return true if successful.
   */
   public abstract boolean compareAndSet(T obj, V expect, V update);
   /**
   * Atomically sets the field of the given object managed by this updater
   * to the given updated value if the current value {@code ==} the
   * expected value. This method is guaranteed to be atomic with respect to
   * other calls to {@code compareAndSet} and {@code set}, but not
   * necessarily with respect to other changes in the field.
   *
   * <p>May <a href="package-summary.html#Spurious" rel="external nofollow" >fail spuriously</a>
   * and does not provide ordering guarantees, so is only rarely an
   * appropriate alternative to {@code compareAndSet}.
   *
   * @param obj An object whose field to conditionally set
   * @param expect the expected value
   * @param update the new value
   * @return true if successful.
   */
   public abstract boolean weakCompareAndSet(T obj, V expect, V update);
   /**
   * Sets the field of the given object managed by this updater to the
   * given updated value. This operation is guaranteed to act as a volatile
   * store with respect to subsequent invocations of {@code compareAndSet}.
   *
   * @param obj An object whose field to set
   * @param newValue the new value
   */
   public abstract void set(T obj, V newValue);
   /**
   * Eventually sets the field of the given object managed by this
   * updater to the given updated value.
   *
   * @param obj An object whose field to set
   * @param newValue the new value
   * @since 1.6
   */
   public abstract void lazySet(T obj, V newValue);
   /**
   * Gets the current value held in the field of the given object managed
   * by this updater.
   *
   * @param obj An object whose field to get
   * @return the current value
   */
   public abstract V get(T obj);
   /**
   * Atomically sets the field of the given object managed by this updater
   * to the given value and returns the old value.
   *
   * @param obj An object whose field to get and set
   * @param newValue the new value
   * @return the previous value
   */
   public V getAndSet(T obj, V newValue) {
     for (;;) {
       V current = get(obj);
       if (compareAndSet(obj, current, newValue))
         return current;
     }
   }
   private static final class AtomicReferenceFieldUpdaterImpl<T,V>
     extends AtomicReferenceFieldUpdater<T,V> {
     private static final Unsafe unsafe = Unsafe.getUnsafe();
     private final long offset;
     private final Class<T> tclass;
     private final Class<V> vclass;
     private final Class cclass;
     /*
     * Internal type checks within all update methods contain
     * internal inlined optimizations checking for the common
     * cases where the class is final (in which case a simple
     * getClass comparison suffices) or is of type Object (in
     * which case no check is needed because all objects are
     * instances of Object). The Object case is handled simply by
     * setting vclass to null in constructor. The targetCheck and
     * updateCheck methods are invoked when these faster
     * screenings fail.
     */
     AtomicReferenceFieldUpdaterImpl(Class<T> tclass,
                     Class<V> vclass,
                     String fieldName,
                     Class<?> caller) {
       Field field = null;
       Class fieldClass = null;
       int modifiers = 0;
       try {
         field = tclass.getDeclaredField(fieldName);
         modifiers = field.getModifiers();
         sun.reflect.misc.ReflectUtil.ensureMemberAccess(
           caller, tclass, null, modifiers);
         sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
         fieldClass = field.getType();
       } catch (Exception ex) {
         throw new RuntimeException(ex);
       }
       if (vclass != fieldClass)
         throw new ClassCastException();
       if (!Modifier.isVolatile(modifiers))
         throw new IllegalArgumentException("Must be volatile type");
       this.cclass = (Modifier.isProtected(modifiers) &&
              caller != tclass) ? caller : null;
       this.tclass = tclass;
       if (vclass == Object.class)
         this.vclass = null;
       else
         this.vclass = vclass;
       offset = unsafe.objectFieldOffset(field);
     }
     void targetCheck(T obj) {
       if (!tclass.isInstance(obj))
         throw new ClassCastException();
       if (cclass != null)
         ensureProtectedAccess(obj);
     }
     void updateCheck(T obj, V update) {
       if (!tclass.isInstance(obj) ||
         (update != null && vclass != null && !vclass.isInstance(update)))
         throw new ClassCastException();
       if (cclass != null)
         ensureProtectedAccess(obj);
     }
     public boolean compareAndSet(T obj, V expect, V update) {
       if (obj == null || obj.getClass() != tclass || cclass != null ||
         (update != null && vclass != null &&
         vclass != update.getClass()))
         updateCheck(obj, update);
       return unsafe.compareAndSwapObject(obj, offset, expect, update);
     }
     public boolean weakCompareAndSet(T obj, V expect, V update) {
       // same implementation as strong form for now
       if (obj == null || obj.getClass() != tclass || cclass != null ||
         (update != null && vclass != null &&
         vclass != update.getClass()))
         updateCheck(obj, update);
       return unsafe.compareAndSwapObject(obj, offset, expect, update);
     }
     public void set(T obj, V newValue) {
       if (obj == null || obj.getClass() != tclass || cclass != null ||
         (newValue != null && vclass != null &&
         vclass != newValue.getClass()))
         updateCheck(obj, newValue);
       unsafe.putObjectVolatile(obj, offset, newValue);
     }
     public void lazySet(T obj, V newValue) {
       if (obj == null || obj.getClass() != tclass || cclass != null ||
         (newValue != null && vclass != null &&
         vclass != newValue.getClass()))
         updateCheck(obj, newValue);
       unsafe.putOrderedObject(obj, offset, newValue);
     }
     public V get(T obj) {
       if (obj == null || obj.getClass() != tclass || cclass != null)
         targetCheck(obj);
       return (V)unsafe.getObjectVolatile(obj, offset);
     }
     private void ensureProtectedAccess(T obj) {
       if (cclass.isInstance(obj)) {
         return;
       }
       throw new RuntimeException(
         new IllegalAccessException("Class " +
           cclass.getName() +
           " can not access a protected member of class " +
           tclass.getName() +
           " using an instance of " +
           obj.getClass().getName()
         )
       );
     }
   }
 }

   下面分析LongFieldTest.java的流程。

1. newUpdater()

newUpdater()的源码如下：

public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
  Class<?> caller = Reflection.getCallerClass();
  if (AtomicLong.VM_SUPPORTS_LONG_CAS)
    return new CASUpdater<U>(tclass, fieldName, caller);
  else
    return new LockedUpdater<U>(tclass, fieldName, caller);
}

说明：newUpdater()的作用是获取一个AtomicIntegerFieldUpdater类型的对象。

它实际上返回的是CASUpdater对象，或者LockedUpdater对象；具体返回哪一个类取决于JVM是否支持long类型的CAS函数。CASUpdater和LockedUpdater都是AtomicIntegerFieldUpdater的子类，它们的实现类似。下面以CASUpdater来进行说明。 

CASUpdater类的源码如下：

public boolean compareAndSet(T obj, long expect, long update) {
  if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
  return unsafe.compareAndSwapLong(obj, offset, expect, update);
}

说明：它实际上是通过CAS函数操作。如果类的long对象的值是expect，则设置它的值为update。 

# java  # concurrency  # 深入了解Java atomic原子类的使用方法和原理  # Java多线程Atomic包操作原子变量与原子类详解  # Java concurrency之AtomicReference原子类_动力节点Java学院整理  # Java concurrency之AtomicLong原子类_动力节点Java学院整理  # Java concurrency之AtomicLongArray原子类_动力节点Java学院整理  # Java的Atomic原子类详解  # 将此  # 设置为  # 子类  # 定值  # 到此  # 则以  # 值为  # 将给  # 的是  # 都是  # 它是  # 以对  # 为给  # 类中  # CallerSensitive  # http  # creativecommons  # Reflection  # domain  # explained 

相关文章： c# 在高并发场景下，委托和接口调用的性能对比  青岛网站建设如何选择本地服务器？  如何彻底删除建站之星生成的Banner？  免费的流程图制作网站有哪些,2025年教师初级职称申报网上流程？  网站网页制作电话怎么打,怎样安装和使用钉钉软件免费打电话？  存储型VPS适合搭建中小型网站吗？  建站之星上传入口如何快速找到？  建站主机功能解析：服务器选择与快速搭建指南  电商网站制作公司有哪些,1688网是什么意思？  如何在Golang中使用replace替换模块_指定本地或远程路径  建站之星免费版是否永久可用？  深圳网站制作的公司有哪些,dido官方网站？  网站制作的方法有哪些,如何将自己制作的网站发布到网上？  品牌网站制作公司有哪些,买正品品牌一般去哪个网站买？  百度网页制作网站有哪些,谁能告诉我百度网站是怎么联系？  如何在IIS服务器上快速部署高效网站？  如何在自有机房高效搭建专业网站？  独立制作一个网站多少钱,建立网站需要花多少钱？  IOS倒计时设置UIButton标题title的抖动问题  微网站制作教程,不会写代码，不会编程，怎么样建自己的网站？  网站规划与制作是什么,电子商务网站系统规划的内容及步骤是什么？  重庆网站制作公司哪家好,重庆中考招生办官方网站？  香港服务器租用每月最低只需15元？  创业网站制作流程,创业网站可靠吗？  nginx修改上传文件大小限制的方法  上海网站制作网页,上海本地的生活网站有哪些？最好包括生活的各个方面的？  建站之星导航配置指南：自助建站与SEO优化全解析  专业网站设计制作公司,如何制作一个企业网站，建设网站的基本步骤有哪些？  如何在阿里云虚拟机上搭建网站？步骤解析与避坑指南  如何通过山东自助建站平台快速注册域名？  济南网站制作的价格,历城一职专官方网站？  如何确保FTP站点访问权限与数据传输安全？  实例解析angularjs的filter过滤器  韩国服务器如何优化跨境访问实现高效连接？  建站之星如何配置系统实现高效建站？  如何在Windows 2008云服务器安全搭建网站？  西安制作网站公司有哪些,西安货运司机用的最多的app或者网站是什么？  建站之星安装失败：服务器环境不兼容？  如何自己制作一个网站链接,如何制作一个企业网站，建设网站的基本步骤有哪些？  零基础网站服务器架设实战：轻量应用与域名解析配置指南  模具网站制作流程,如何找模具客户？  如何快速生成ASP一键建站模板并优化安全性？  建站之星价格显示格式升级，你的预算足够吗？  建站主机选哪种环境更利于SEO优化？  建站之星IIS配置教程：代码生成技巧与站点搭建指南  郑州企业网站制作公司,郑州招聘网站有哪些？  如何用低价快速搭建高质量网站？  制作旅游网站html,怎样注册旅游网站？  西安市网站制作公司,哪个相亲网站比较好?西安比较好的相亲网站？  道歉网站制作流程,世纪佳缘致歉小吴事件，相亲网站身份信息伪造该如何稽查？