模块 java.base
包 java.lang.invoke

类 VarHandle

java.lang.Object
java.lang.invoke.VarHandle
所有已实现的接口：
Constable
public abstract sealed class VarHandle extends Object implements Constable
VarHandle 是对变量或参数定义的变量族的动态强类型引用，包括静态字段、非静态字段、数组元素或堆外数据结构的组件。各种 access modes 支持对此类变量的访问，包括普通读/写访问、易失性读/写访问以及比较和设置。

VarHandles 是不可变的并且没有可见状态。 VarHandles 不能被用户子类化。

VarHandle 具有：

  • a variable type T，此VarHandle引用的每个变量的类型；和
  • coordinate types CT1, CT2, ..., CTn 的列表， coordinate expressions 的类型共同定位此 VarHandle 引用的变量。
变量和坐标类型可以是原始类型或引用类型，由 Class 个对象表示。坐标类型列表可能为空。

生产 lookup VarHandle 实例的工厂方法记录了支持的变量类型和坐标类型列表。

每个访问模式都与一个 access mode method 相关联，一个以访问模式命名的 签名多态 方法。当在 VarHandle 实例上调用访问模式方法时，调用的初始参数是坐标表达式，精确指示要在哪个对象中访问变量。调用的尾随参数表示访问模式的重要性值。例如，各种比较和设置或比较和交换访问模式需要变量的期望值和新值的两个尾随参数。

不静态检查调用访问模式方法的参数的数量和类型。相反，每个访问模式方法都指定一个 access mode type ，表示为 MethodType 的一个实例，用作一种方法签名，根据它动态检查参数。访问模式类型根据 VarHandle 实例的坐标类型和对访问模式重要的值的类型给出形式参数类型。访问模式类型还提供返回类型，通常根据 VarHandle 实例的变量类型。当在 VarHandle 实例上调用访问模式方法时，调用站点的符号类型描述符、调用参数的运行时类型以及返回值的运行时类型必须match访问模式中给出的类型类型。如果匹配失败，将抛出运行时异常。例如，访问模式方法 compareAndSet(java.lang.Object...) 指定如果其接收者是坐标类型为 CT1, ..., CTn 且变量类型为 T 的 VarHandle 实例，则其访问模式类型为 (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean 。假设一个 VarHandle 实例可以访问数组元素，并且它的坐标类型是 String[] 和 int 而它的变量类型是 String 。此 VarHandle 实例上 compareAndSet 的访问模式类型为 (String[] c1, int c2, String expectedValue, String newValue)boolean。这样的 VarHandle 实例可以由 array factory method 生成并访问数组元素，如下所示：

 
 String[] sa = ...
 VarHandle avh = MethodHandles.arrayElementVarHandle(String[].class);
 boolean r = avh.compareAndSet(sa, 10, "expected", "new");

访问模式控制原子性和一致性属性。 Plain 读 (get) 和写 (set) 访问保证仅对引用和最多 32 位的原始值是按位原子的，并且对执行线程以外的线程没有施加任何可观察到的排序约束。 Opaque 操作是按位原子的，并且相对于对同一变量的访问是连贯有序的。除了遵守不透明属性之外，Acquire 模式读取及其后续访问在匹配 Release 模式写入及其先前访问之后进行排序。除了遵守 Acquire 和 Release 属性外，所有 Volatile 操作都完全相互排序。

访问模式分为以下几类：

生产 lookup VarHandle 实例的工厂方法记录了受支持的访问模式集，其中还可能包括基于变量类型和变量是否只读的记录限制。如果不支持访问模式，则相应的访问模式方法将在调用时抛出 UnsupportedOperationException 。工厂方法应该记录访问模式方法可能抛出的任何其他未声明的异常。所有 VarHandle 实例都支持 get 访问模式，相应的方法永远不会抛出 UnsupportedOperationException。如果 VarHandle 引用只读变量（例如 final 字段），则不支持写入、原子更新、数字原子更新和按位原子更新访问模式，并且相应的方法会抛出 UnsupportedOperationException 。读/写访问模式（如果支持），除了 get 和 set ，为引用类型和所有原始类型提供原子访问。除非在工厂方法的文档中另有说明，否则访问模式 get 和 set（如果支持）为引用类型和所有基元类型提供原子访问，但 32 位平台上的 long 和 double 除外。

访问模式将覆盖在变量声明位置指定的任何内存排序效果。例如，使用 get 访问模式访问字段的 VarHandle 将按照指定的 by its access mode 访问该字段，即使该字段声明为 volatile 也是如此。执行混合访问时应格外小心，因为 Java 内存模型可能会产生意想不到的结果。

除了支持在各种访问模式下访问变量，还提供了一组静态方法，称为内存栅栏方法，用于对内存排序的细粒度控制。 Java 语言规范允许其他线程观察操作，就好像它们是以不同于程序源代码中明显的顺序执行的那样，受到产生的约束，例如，来自锁、volatile 字段或 VarHandles 的使用。静态方法 fullFence 、 acquireFence 、 releaseFence 、 loadLoadFence 和 storeStoreFence 也可用于施加约束。与某些访问模式的情况一样，它们的规范是根据缺乏“重新排序”来表述的——如果没有栅栏，则可能会发生可观察到的排序效果。访问模式方法和内存栅栏方法的规范的更精确的措辞可能伴随 Java 语言规范的未来更新。

编译访问模式方法的调用

命名访问模式方法的 Java 方法调用表达式可以从 Java 源代码调用 VarHandle。从源代码的角度来看，这些方法可以接受任何参数，并且它们的多态结果（如果表示）可以转换为任何返回类型。形式上，这是通过为访问模式方法提供变量 arity Object arguments 和 Object return types（如果返回类型是多态的）来实现的，但是它们具有称为 signature polymorphism 的附加特性，它将这种调用自由直接连接到 JVM 执行堆栈。

与虚拟方法一样，对访问模式方法的源代码级调用编译为 invokevirtual 指令。更不寻常的是，编译器必须记录实际的参数类型，并且可能不会对参数执行方法调用转换。相反，它必须生成指令，根据它们自己未转换的类型将它们压入堆栈。 VarHandle 对象本身将在参数之前被压入堆栈。然后，编译器生成一条 invokevirtual 指令，该指令使用描述参数和返回类型的符号类型描述符调用访问模式方法。

要发出完整的符号类型描述符，编译器还必须确定返回类型（如果是多态的）。这是基于对方法调用表达式的强制转换（如果有），或者如果调用是表达式则为 Object，如果调用是语句则为 void。转换可能是原始类型（但不是 void ）。

作为极端情况，未转换的 null 参数被赋予 java.lang.Void 的符号类型描述符。 Void 类型的歧义是无害的，因为除了 null 引用之外没有 Void 类型的引用。

执行访问模式方法的调用

第一次执行 invokevirtual 指令时，通过符号解析指令中的名称并验证方法调用是否静态合法来链接它。这也适用于访问模式方法的调用。在这种情况下，将检查编译器发出的符号类型描述符的语法是否正确，并解析其中包含的名称。因此，调用访问模式方法的 invokevirtual 指令将始终链接，只要符号类型描述符在句法上格式正确并且类型存在。

链接后执行invokevirtual时，JVM 首先检查接收 VarHandle 的访问模式类型，以确保它与符号类型描述符匹配。如果类型匹配失败，则意味着调用者正在调用的访问模式方法不存在于正在调用的单个 VarHandle 上。

默认情况下，调用访问模式方法的行为就像调用 MethodHandle.invoke(java.lang.Object...) 一样，其中接收方法句柄接受 VarHandle 实例作为主要参数。更具体地说，如下，其中 {access-mode} 对应于访问模式方法名称：

 
 VarHandle vh = ..
 R r = (R) vh.{access-mode}(p1, p2, ..., pN);
的行为就像： 
 
 VarHandle vh = ..
 VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
 MethodHandle mh = MethodHandles.varHandleExactInvoker(
            am,
            vh.accessModeType(am));

 R r = (R) mh.invoke(vh, p1, p2, ..., pN)
（模访问模式方法不声明抛出 Throwable）。这等效于： 
 
 MethodHandle mh = MethodHandles.lookup().findVirtual(
            VarHandle.class,
            "{access-mode}",
            MethodType.methodType(R, p1, p2, ..., pN));

 R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
，其中所需的方法类型是符号类型描述符并执行 MethodHandle.invokeExact(java.lang.Object...) ，因为在调用目标之前，句柄将根据需要应用引用强制转换和装箱、拆箱或加宽原始值，就像通过asType （另见 MethodHandles.varHandleInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType) ）。更简洁地说，这种行为等同于： 
 
 VarHandle vh = ..
 VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
 MethodHandle mh = vh.toMethodHandle(am);

 R r = (R) mh.invoke(p1, p2, ..., pN)
其中，在这种情况下，方法句柄绑定到 VarHandle 实例。

可以调整 VarHandle 的调用行为（请参阅 withInvokeExactBehavior() ），这样访问模式方法的调用就像调用 MethodHandle.invokeExact(java.lang.Object...) 一样，其中接收方法句柄接受 VarHandle 实例作为主要参数。更具体地说，如下，其中 {access-mode} 对应于访问模式方法名称：

 
 VarHandle vh = ..
 R r = (R) vh.{access-mode}(p1, p2, ..., pN);
的行为就像： 
 
 VarHandle vh = ..
 VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
 MethodHandle mh = MethodHandles.varHandleExactInvoker(
            am,
            vh.accessModeType(am));

 R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
（模访问模式方法不声明抛出 Throwable）。更简洁地说，这种行为等同于： 
 
 VarHandle vh = ..
 VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
 MethodHandle mh = vh.toMethodHandle(am);

 R r = (R) mh.invokeExact(p1, p2, ..., pN)
其中，在这种情况下，方法句柄绑定到 VarHandle 实例。

调用检查

在典型的程序中，VarHandle 访问模式类型匹配通常会成功。但如果匹配失败，JVM 将抛出一个 WrongMethodTypeException 。

因此，在静态类型程序中可能显示为链接错误的访问模式类型不匹配在使用 VarHandles 的程序中可能显示为动态 WrongMethodTypeException。

因为访问模式类型包含“活动的”Class 对象，所以方法类型匹配会同时考虑类型名称和类加载器。因此，即使 VarHandle VH 在一个类加载器 L1 中创建并在另一个类加载器 L2 中使用，VarHandle 访问模式方法调用也是类型安全的，因为调用者的符号类型描述符（在 L2 中解析）与原始被调用方法的符号类型匹配类型描述符，在 L1 中解决。 L1 中的解析发生在创建 VH 并分配其访问模式类型时，而 L2 中的解析发生在链接 invokevirtual 指令时。

除了类型描述符检查之外，VarHandles 访问其变量的能力不受限制。如果 VarHandle 由有权访问该变量的类在非公共变量上形成，则生成的 VarHandle 可以由接收到它的引用的任何调用者在任何地方使用。

与 Core Reflection API 不同，每次调用反射方法时都会检查访问权限，VarHandle 访问权限检查是执行的创建VarHandle时。因此，非公共变量或非公共类中的变量的 VarHandles 通常应该保密。它们不应传递给不受信任的代码，除非不受信任的代码使用它们是无害的。

VarHandle 创建

Java 代码可以创建一个 VarHandle，它可以直接访问该代码可以访问的任何字段。这是通过名为 MethodHandles.Lookup 的反射式、基于功能的 API 完成的。例如，可以从 Lookup.findVarHandle 获得非静态字段的 VarHandle。还有一个来自 Core Reflection API 对象的转换方法，Lookup.unreflectVarHandle 。

对受保护字段成员的访问仅限于访问类或其子类之一的接收者，并且访问类必须反过来是受保护成员定义类的子类（或包兄弟）。如果 VarHandle 引用当前包外的声明类的受保护非静态字段，则接收者参数将缩小为访问类的类型。

VarHandles 和 Core Reflection API 之间的互操作

使用 Lookup API 中的工厂方法，可以将核心反射 API 对象表示的任何字段转换为行为等效的 VarHandle。例如，可以使用 Lookup.unreflectVarHandle 将反射 Field 转换为 VarHandle。生成的 VarHandles 通常提供对基础字段的更直接和有效的访问。

作为一个特例，当使用Core Reflection API查看该类中的签名多态访问方式方法时，它们表现为普通的非多态方法。它们的反射外观，如 Class.getDeclaredMethod 所见，不受它们在此 API 中的特殊状态的影响。例如，Method.getModifiers 将准确报告任何类似声明的方法所需的修饰符位，在本例中包括 native 和 varargs 位。

与任何反射方法一样，这些方法（反射时）可以通过 java.lang.reflect.Method.invoke 、JNI 或间接通过 Lookup.unreflect 调用。但是，此类反射调用不会导致访问模式方法调用。这样的调用，如果传递了所需的参数（单个参数，类型为 Object[] ），将忽略该参数并抛出一个 UnsupportedOperationException 。

由于 invokevirtual 指令可以在任何符号类型描述符下本地调用 VarHandle 访问模式方法，因此这种反射视图与通过字节码对这些方法的正常表示相冲突。因此，当 Class.getDeclaredMethod 反思地查看这些本地方法时，可能仅将其视为占位符。

为了获得特定访问模式类型的调用程序方法，请使用 MethodHandles.varHandleExactInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType) 或 MethodHandles.varHandleInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType) 。 Lookup.findVirtual API 还能够返回一个方法句柄来为任何指定的访问模式类型调用访问模式方法，并且在行为上等同于 MethodHandles.varHandleInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType) 。

VarHandles 和 Java 泛型之间的互操作

可以为使用 Java 泛型类型声明的变量（例如字段）获取 VarHandle。与 Core Reflection API 一样，VarHandle 的变量类型将从源级类型的擦除中构造。当调用 VarHandle 访问模式方法时，其参数类型或返回值转换类型可能是泛型类型或类型实例。如果发生这种情况，编译器将在为 invokevirtual 指令构造符号类型描述符时用擦除替换这些类型。
自从：
9
参见：

  • 方法详情

    • hasInvokeExactBehavior

      public boolean hasInvokeExactBehavior()
      如果此 VarHandle 具有 invoke-exact behavior ，则返回 true。
      返回：
      true 如果这个 VarHandle 有 invoke-exact behavior 。
      自从：
      16
      参见：

    • get

      public final Object  get(Object ... args)
      返回变量的值，具有读取的内存语义，就好像变量被声明为 non-volatile 一样。通常称为普通读取访问。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn)T 。

      get 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET) 结果的访问模式类型相匹配。

      所有 VarHandle 实例都支持此访问模式，并且永远不会抛出 UnsupportedOperationException 。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为变量值的签名多态结果，使用 Object 静态表示。
      抛出：
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • set

      public final void set(Object ... args)
      将变量的值设置为 newValue ，设置的内存语义就好像变量被声明为 non-volatile 和 non-final 一样。通常称为普通写访问。

      方法签名的形式为(CT1 ct1, ..., CTn ctn, T newValue)void

      set 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.SET) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • getVolatile

      public final Object  getVolatile(Object ... args)
      返回变量的值，具有读取的内存语义，就好像变量被声明为 volatile 一样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn)T 。

      getVolatile 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_VOLATILE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为变量值的签名多态结果，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • setVolatile

      public final void setVolatile(Object ... args)
      将变量的值设置为 newValue ，设置的内存语义就好像变量被声明为 volatile 一样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T newValue)void 。

      setVolatile 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.SET_VOLATILE) 结果的访问模式类型相匹配。

      API 注意：
      忽略与 C 和 C++ 的许多语义差异，此方法具有与 memory_order_seq_cst 兼容的内存排序效果。
      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • getOpaque

      public final Object  getOpaque(Object ... args)
      返回变量的值，按程序顺序访问，但不保证相对于其他线程的内存排序效果。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn)T 。

      getOpaque 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_OPAQUE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为变量值的签名多态结果，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • setOpaque

      public final void setOpaque(Object ... args)
      按程序顺序将变量的值设置为 newValue ，但不保证相对于其他线程的内存排序效果。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T newValue)void 。

      setOpaque 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.SET_OPAQUE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • getAcquire

      public final Object  getAcquire(Object ... args)
      返回变量的值，并确保后续加载和存储在此访问之前不会重新排序。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn)T 。

      getAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_ACQUIRE) 结果的访问模式类型相匹配。

      API 注意：
      忽略与 C 和 C++ 的许多语义差异，此方法具有与 memory_order_acquire 排序兼容的内存排序效果。
      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为变量值的签名多态结果，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • setRelease

      public final void setRelease(Object ... args)
      将变量的值设置为 newValue ，并确保在此访问后不会重新排序之前的加载和存储。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T newValue)void 。

      setRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.SET_RELEASE) 结果的访问模式类型相匹配。

      API 注意：
      忽略与 C 和 C++ 的许多语义差异，此方法具有与 memory_order_release 排序兼容的内存排序效果。
      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。

    • compareAndSet

      public final boolean compareAndSet(Object ... args)
      如果变量的当前值被称为 witness value、== 和 expectedValue，使用 getVolatile(java.lang.Object...) 的内存语义访问，则以原子方式将变量的值设置为具有 setVolatile(java.lang.Object...) 的内存语义的 newValue。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean 。

      compareAndSet 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.COMPARE_AND_SET) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      true 如果成功，否则 false 如果见证值与 expectedValue 不同。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • compareAndExchange

      public final Object  compareAndExchange(Object ... args)
      如果变量的当前值被称为 witness value、== 和 expectedValue，使用 getVolatile(java.lang.Object...) 的内存语义访问，则以原子方式将变量的值设置为具有 setVolatile(java.lang.Object...) 的内存语义的 newValue。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T 。

      compareAndExchange 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为见证值的签名多态结果，如果成功，它将与 expectedValue 相同，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不兼容。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符兼容，但引用转换失败。
      参见：

    • compareAndExchangeAcquire

      public final Object  compareAndExchangeAcquire(Object ... args)
      如果变量的当前值被称为 witness value、== 和 expectedValue，使用 getAcquire(java.lang.Object...) 的内存语义访问，则以原子方式将变量的值设置为具有 set(java.lang.Object...) 的内存语义的 newValue。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T 。

      compareAndExchangeAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为见证值的签名多态结果，如果成功，它将与 expectedValue 相同，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • compareAndExchangeRelease

      public final Object  compareAndExchangeRelease(Object ... args)
      如果变量的当前值被称为 witness value、== 和 expectedValue，使用 get(java.lang.Object...) 的内存语义访问，则以原子方式将变量的值设置为具有 setRelease(java.lang.Object...) 的内存语义的 newValue。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T 。

      compareAndExchangeRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      作为见证值的签名多态结果，如果成功，它将与 expectedValue 相同，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • weakCompareAndSetPlain

      public final boolean weakCompareAndSetPlain(Object ... args)
      如果变量的当前值被称为 witness value、== 和 expectedValue，可以使用 get(java.lang.Object...) 的内存语义访问，则可能原子地将变量的值设置为具有 set(java.lang.Object...) 语义的 newValue。

      即使见证值确实与预期值匹配，此操作也可能会虚假地失败（通常是由于内存争用）。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean 。

      weakCompareAndSetPlain 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      true 如果成功，否则 false 如果 witness 值与 expectedValue 不同或此操作虚假失败。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • weakCompareAndSet

      public final boolean weakCompareAndSet(Object ... args)
      如果变量的当前值（称为 witness value、== 和 expectedValue，使用 getVolatile(java.lang.Object...) 的内存语义访问），可能会自动将变量的值设置为具有 setVolatile(java.lang.Object...) 的内存语义的 newValue。

      即使见证值确实与预期值匹配，此操作也可能会虚假地失败（通常是由于内存争用）。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean 。

      weakCompareAndSet 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      true 如果成功，否则 false 如果 witness 值与 expectedValue 不同或此操作虚假失败。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • weakCompareAndSetAcquire

      public final boolean weakCompareAndSetAcquire(Object ... args)
      如果变量的当前值（称为 witness value、== 和 expectedValue，使用 getAcquire(java.lang.Object...) 的内存语义访问），则可能以原子方式将变量的值设置为具有 set(java.lang.Object...) 语义的 newValue。

      即使见证值确实与预期值匹配，此操作也可能会虚假地失败（通常是由于内存争用）。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean 。

      weakCompareAndSetAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      true 如果成功，否则 false 如果 witness 值与 expectedValue 不同或此操作虚假失败。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • weakCompareAndSetRelease

      public final boolean weakCompareAndSetRelease(Object ... args)
      如果变量的当前值（称为 witness value、== 和 expectedValue，使用 get(java.lang.Object...) 的内存语义访问），可能会自动将变量的值设置为具有 setRelease(java.lang.Object...) 语义的 newValue。

      即使见证值确实与预期值匹配，此操作也可能会虚假地失败（通常是由于内存争用）。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean 。

      weakCompareAndSetRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      true 如果成功，否则 false 如果 witness 值与 expectedValue 不同或此操作虚假失败。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndSet

      public final Object  getAndSet(Object ... args)
      以原子方式将变量的值设置为具有 setVolatile(java.lang.Object...) 的内存语义的 newValue 并返回变量的先前值，如使用 getVolatile(java.lang.Object...) 的内存语义访问的那样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T newValue)T 。

      getAndSet 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_SET) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndSetAcquire

      public final Object  getAndSetAcquire(Object ... args)
      以原子方式将变量的值设置为具有 set(java.lang.Object...) 的内存语义的 newValue 并返回变量的先前值，如使用 getAcquire(java.lang.Object...) 的内存语义访问的那样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T newValue)T 。

      getAndSetAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_SET_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndSetRelease

      public final Object  getAndSetRelease(Object ... args)
      以原子方式将变量的值设置为具有 setRelease(java.lang.Object...) 的内存语义的 newValue 并返回变量的先前值，如使用 get(java.lang.Object...) 的内存语义访问的那样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T newValue)T 。

      getAndSetRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_SET_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T newValue) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndAdd

      public final Object  getAndAdd(Object ... args)
      以原子方式将 value 添加到具有 setVolatile(java.lang.Object...) 内存语义的变量的当前值，并返回变量的先前值，如使用 getVolatile(java.lang.Object...) 内存语义访问的那样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T value)T 。

      getAndAdd 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_ADD) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T value) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndAddAcquire

      public final Object  getAndAddAcquire(Object ... args)
      以原子方式将 value 添加到具有 set(java.lang.Object...) 内存语义的变量的当前值，并返回变量的先前值，如使用 getAcquire(java.lang.Object...) 内存语义访问的那样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T value)T 。

      getAndAddAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T value) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndAddRelease

      public final Object  getAndAddRelease(Object ... args)
      以原子方式将 value 添加到具有 setRelease(java.lang.Object...) 内存语义的变量的当前值，并返回变量的先前值，如使用 get(java.lang.Object...) 内存语义访问的那样。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T value)T 。

      getAndAddRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_ADD_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T value) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseOr

      public final Object  getAndBitwiseOr(Object ... args)
      原子地将变量的值设置为变量的当前值与具有 setVolatile(java.lang.Object...) 的内存语义的 mask 之间按位或的结果，并返回变量的先前值，如使用 getVolatile(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑或而不是按位或。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseOr 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseOrAcquire

      public final Object  getAndBitwiseOrAcquire(Object ... args)
      原子地将变量的值设置为变量的当前值与具有 set(java.lang.Object...) 的内存语义的 mask 之间的按位或的结果，并返回变量的先前值，如使用 getAcquire(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑或而不是按位或。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseOrAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseOrRelease

      public final Object  getAndBitwiseOrRelease(Object ... args)
      以原子方式将变量的值设置为变量的当前值与具有 setRelease(java.lang.Object...) 的内存语义的 mask 之间按位或的结果，并返回变量的先前值，如使用 get(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑或而不是按位或。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseOrRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseAnd

      public final Object  getAndBitwiseAnd(Object ... args)
      原子地将变量的值设置为变量的当前值与具有 setVolatile(java.lang.Object...) 的内存语义的 mask 之间的按位与的结果，并返回变量的先前值，如使用 getVolatile(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑与而不是按位与。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseAnd 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseAndAcquire

      public final Object  getAndBitwiseAndAcquire(Object ... args)
      原子地将变量的值设置为变量的当前值与具有 set(java.lang.Object...) 的内存语义的 mask 之间的按位与的结果，并返回变量的先前值，如使用 getAcquire(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑与而不是按位与。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseAndAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseAndRelease

      public final Object  getAndBitwiseAndRelease(Object ... args)
      以原子方式将变量的值设置为变量的当前值与具有 setRelease(java.lang.Object...) 的内存语义的 mask 之间的按位与的结果，并返回变量的先前值，如使用 get(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑与而不是按位与。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseAndRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseXor

      public final Object  getAndBitwiseXor(Object ... args)
      以原子方式将变量的值设置为变量的当前值与具有 setVolatile(java.lang.Object...) 的内存语义的 mask 之间按位异或的结果，并返回变量的先前值，如使用 getVolatile(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑 XOR 而不是按位 XOR。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseXor 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseXorAcquire

      public final Object  getAndBitwiseXorAcquire(Object ... args)
      以原子方式将变量的值设置为变量的当前值与具有 set(java.lang.Object...) 的内存语义的 mask 之间按位异或的结果，并返回变量的先前值，如使用 getAcquire(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑 XOR 而不是按位 XOR。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseXorAcquire 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • getAndBitwiseXorRelease

      public final Object  getAndBitwiseXorRelease(Object ... args)
      以原子方式将变量的值设置为变量的当前值与具有 setRelease(java.lang.Object...) 的内存语义的 mask 之间按位异或的结果，并返回变量的先前值，如使用 get(java.lang.Object...) 的内存语义访问的那样。

      如果变量类型是非整数 boolean 类型，则执行逻辑 XOR 而不是按位 XOR。

      方法签名的形式为 (CT1 ct1, ..., CTn ctn, T mask)T 。

      getAndBitwiseXorRelease 调用站点的符号类型描述符必须与在此 VarHandle 上调用 accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE) 结果的访问模式类型相匹配。

      参数：
      args - 形式为 (CT1 ct1, ..., CTn ctn, T mask) 的签名多态参数列表，使用可变参数静态表示。
      返回：
      签名多态结果，即变量的先前值，使用 Object 静态表示。
      抛出：
      UnsupportedOperationException - 如果此 VarHandle 不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见：

    • withInvokeExactBehavior

      public abstract VarHandle  withInvokeExactBehavior()
      返回一个 VarHandle，可以访问与此 VarHandle 相同的变量，但其访问模式方法的调用行为已调整为 invoke-exact behavior 。

      如果此 VarHandle 已经具有调用精确行为，则返回此 VarHandle。

      在返回的 var 句柄上调用 hasInvokeExactBehavior() 保证返回 true 。

      API 注意：
      Invoke-exact 行为保证在调用访问模式方法时，参数的类型和参数必须与 access mode type 匹配，否则将抛出 WrongMethodTypeException 。
      返回：
      具有调用精确行为的 VarHandle
      自从：
      16
      参见：

    • withInvokeBehavior

      public abstract VarHandle  withInvokeBehavior()
      返回一个 VarHandle，可以访问与此 VarHandle 相同的变量，但其访问模式方法的调用行为已调整为 invoke behavior 。

      如果此 VarHandle 已经具有调用行为，则返回此 VarHandle。

      在返回的 var 句柄上调用 hasInvokeExactBehavior() 保证返回 false 。

      返回：
      具有调用行为的 VarHandle
      自从：
      16
      参见：

    • toString

      public final String  toString()
      返回此 VarHandle 的紧凑文本描述，包括描述的变量类型及其坐标的描述。
      重写：
      toString 在类 Object 中
      返回：
      这个 VarHandle 的紧凑文本描述

    • varType

      public Class <?> varType()
      返回此 VarHandle 引用的变量的变量类型。
      返回：
      此 VarHandle 引用的变量的变量类型

    • coordinateTypes

      public List <Class <?>> coordinateTypes()
      返回此 VarHandle 的坐标类型。
      返回：
      此 VarHandle 的坐标类型。返回列表不可修改

    • accessModeType

      public final MethodType  accessModeType(VarHandle.AccessMode  accessMode)
      获取此 VarHandle 的访问模式类型和给定的访问模式。

      访问模式类型的参数类型将包含一个前缀，该前缀是此 VarHandle 的坐标类型，后跟访问模式方法定义的其他类型。访问模式类型的返回类型由访问模式方法的返回类型定义。

      参数：
      accessMode - 访问模式，对应同名的签名多态方法
      返回：
      给定访问模式的访问模式类型

    • isAccessModeSupported

      public final boolean isAccessModeSupported(VarHandle.AccessMode  accessMode)
      如果支持给定的访问模式，则返回 true，否则返回 false。

      给定访问模式返回 false 值表示在调用相应的访问模式方法时抛出 UnsupportedOperationException。

      参数：
      accessMode - 访问模式，对应同名的签名多态方法
      返回：
      true 如果支持给定的访问模式，否则 false 。

    • toMethodHandle

      public MethodHandle  toMethodHandle(VarHandle.AccessMode  accessMode)
      获得绑定到此 VarHandle 和给定访问模式的方法句柄。
      API 注意：
      此方法对于 VarHandle vh 和访问模式 {access-mode} 返回一个方法句柄，该句柄等效于以下代码中的方法句柄 bmh（尽管它可能更有效）： 
      
 MethodHandle mh = MethodHandles.varHandleExactInvoker(
            vh.accessModeType(VarHandle.AccessMode.{access-mode}));

 MethodHandle bmh = mh.bindTo(vh);
      参数：
      accessMode - 访问模式，对应同名的签名多态方法
      返回：
      绑定到此 VarHandle 和给定访问模式的方法句柄

    • describeConstable

      public Optional <VarHandle.VarHandleDesc > describeConstable()
      如果可以构造，则返回此实例的标称描述符，如果不能构造，则返回一个空的Optional 。
      指定者：
      describeConstable 在接口 Constable 中
      返回：
      包含生成的标称描述符的 Optional ，或者如果无法构造则为空的 Optional 。
      自从：
      12

    • fullFence

      public static void fullFence()
      确保栅栏之前的装载和存储不会与栅栏之后的装载和存储重新排序。
      API 注意：
      忽略与 C 和 C++ 的许多语义差异，此方法具有与 atomic_thread_fence(memory_order_seq_cst) 兼容的内存排序效果

    • acquireFence

      public static void acquireFence()
      确保栅栏前的负载不会与栅栏后的负载和存储重新排序。
      API 注意：
      忽略与 C 和 C++ 的许多语义差异，此方法具有与 atomic_thread_fence(memory_order_acquire) 兼容的内存排序效果

    • releaseFence

      public static void releaseFence()
      确保栅栏之前的装载和存储不会与栅栏之后的存储重新排序。
      API 注意：
      忽略与 C 和 C++ 的许多语义差异，此方法具有与 atomic_thread_fence(memory_order_release) 兼容的内存排序效果

    • loadLoadFence

      public static void loadLoadFence()
      确保栅栏前的负载不会与栅栏后的负载重新排序。

    • storeStoreFence

      public static void storeStoreFence()
      确保围栏之前的商店不会与围栏之后的商店重新排序。