Module java.base
Package java.lang.invoke

Class VarHandle

java.lang.Object
java.lang.invoke.VarHandle
所有已实现的接口:
Constable
public abstract sealed class VarHandle extends Object implements Constable
VarHandle是对变量的动态强类型引用，或者对参数化定义的变量族的引用，包括静态字段、非静态字段、数组元素或堆外数据结构的组件。支持对这些变量的访问，包括普通读/写访问、volatile读/写访问以及比较和设置。访问模式。VarHandles是不可变的，没有可见状态。VarHandles不能被用户子类化。

VarHandle具有：

  • 一个变量类型 T，表示此VarHandle引用的每个变量的类型；和
  • 一个坐标类型 CT1, CT2, ..., CTn的列表，表示联合定位此VarHandle引用的变量的坐标表达式的类型。
变量和坐标类型可以是原始类型或引用类型，并由Class对象表示。坐标类型的列表可以为空。

生成或查找VarHandle实例的工厂方法记录了支持的变量类型和坐标类型。

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

访问模式方法的调用参数的数量和类型不会在静态时进行检查。相反，每个访问模式方法指定一个访问模式类型，表示为MethodType的实例，用作一种方法签名，对其进行动态检查。访问模式类型根据VarHandle实例的坐标类型和访问模式的重要值的类型给出形式参数类型。访问模式类型还给出一个返回类型，通常是根据VarHandle实例的变量类型。当在VarHandle实例上调用访问模式方法时，调用点的符号类型描述符、调用的参数的运行时类型以及返回值的运行时类型必须匹配访问模式类型中给定的类型。如果匹配失败，则会抛出运行时异常。例如，访问模式方法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实例，并如下访问数组元素：

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

访问模式控制原子性和一致性属性。普通读取（get）和写入（set）访问仅对引用和最多32位的原始值保证按位原子，并且不对除执行线程之外的线程的顺序施加可观察的顺序约束。不透明操作是按位原子的，并且与对同一变量的访问一致排序。除了遵守不透明属性外，获取模式读取及其后续访问在匹配释放模式写入及其先前访问之后排序。除了遵守获取和释放属性外，所有易失性操作在彼此之间是完全有序的。

访问模式分为以下类别：

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

访问模式将覆盖在变量声明处指定的内存排序效果。例如，使用get访问模式访问字段的VarHandle将按照其访问模式访问字段，即使该字段被声明为volatile。在执行混合访问时应格外小心，因为Java内存模型可能会产生令人惊讶的结果。

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

编译访问模式方法的调用

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

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

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

作为一个特例，未经转换的null参数被赋予java.lang.Void的符号类型描述符。与类型Void的歧义是无害的，因为除了空引用之外，没有类型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中解析时匹配。在创建VH并分配其访问模式类型时，L1中的解析发生，而在链接invokevirtual指令时，L2中的解析发生。

除了类型描述符检查外，VarHandle访问其变量的能力是无限制的。如果VarHandle在具有对该变量的访问权限的类中形成了一个非公共变量，那么由此产生的VarHandle可以被任何接收到它的引用的调用者在任何地方使用。

与核心反射API不同，核心反射方法每次被调用时都会检查访问权限，VarHandle访问检查是在创建VarHandle时进行的。因此，对于非公共变量或非公共类中的变量的VarHandles，通常应保密。除非从不受信任的代码中使用它们是无害的，否则不应将它们传递给不受信任的代码。

VarHandle创建

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

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

VarHandles与核心反射API之间的互操作

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

作为一个特例，当使用核心反射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。与核心反射API一样，VarHandle的变量类型将从源级别类型的擦除构造。当调用VarHandle访问模式方法时，其参数的类型或返回值的强制转换类型可能是泛型类型或类型实例。如果发生这种情况，编译器将在构造invokevirtual指令的符号类型描述符时，将这些类型替换为它们的擦除形式。
自JDK版本:
9
参见:

  • Method Details

    • hasInvokeExactBehavior

      public boolean hasInvokeExactBehavior()
      如果此VarHandle具有精确调用行为，则返回true。
      返回:
      如果此VarHandle具有精确调用行为，则返回true。
      自：
      16
      参见：

    • get

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

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

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

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

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

    • set

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

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

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

      参数:
      args - 形式为(CT1 ct1, ..., CTn ctn, T newValue)的签名多态参数列表，使用varargs进行静态表示。
      抛出:
      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)的签名多态参数列表，使用varargs进行静态表示。
      返回:
      静态表示为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)的签名多态参数列表，使用varargs进行静态表示。
      抛出:
      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)的签名多态参数列表，使用varargs进行静态表示。
      返回:
      静态表示为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)
      使用 setVolatile(java.lang.Object...) 的内存语义原子地将变量的值设置为 newValue，如果变量的当前值，称为 见证值，== expectedValue，则使用 getVolatile(java.lang.Object...) 的内存语义访问。

      方法签名的形式为 (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)
      使用 setVolatile(java.lang.Object...) 的内存语义原子地将变量的值设置为 newValue，如果变量的当前值，称为 见证值，== expectedValue，则使用 getVolatile(java.lang.Object...) 的内存语义访问。

      方法签名的形式为 (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)
      使用 set(java.lang.Object...) 的内存语义原子地将变量的值设置为 newValue，如果变量的当前值，称为 见证值，== expectedValue，则使用 getAcquire(java.lang.Object...) 的内存语义访问。

      方法签名的形式为 (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)
      使用 setRelease(java.lang.Object...) 的内存语义原子地将变量的值设置为 newValue，如果变量的当前值，称为 见证值，== expectedValue，则使用 get(java.lang.Object...) 的内存语义访问。

      方法签名的形式为 (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)的签名多态参数列表，使用varargs静态表示。
      返回:
      签名多态结果是见证值，如果成功将与expectedValue相同，静态表示为Object。
      抛出:
      UnsupportedOperationException - 如果对于此VarHandle不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见:

    • weakCompareAndSetPlain

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

      即使见证值与期望值匹配，此操作也可能出现故障（通常是由于内存争用）。

      方法签名形式为(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)的签名多态参数列表，使用varargs静态表示。
      返回:
      如果成功则true，否则false，如果见证值与expectedValue不同或此操作出现故障。
      抛出:
      UnsupportedOperationException - 如果对于此VarHandle不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见:

    • weakCompareAndSet

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

      即使见证值与期望值匹配，此操作也可能出现故障（通常是由于内存争用）。

      方法签名形式为(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)的签名多态参数列表，使用varargs静态表示。
      返回:
      如果成功则true，否则false，如果见证值与expectedValue不同或此操作出现故障。
      抛出:
      UnsupportedOperationException - 如果对于此VarHandle不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见:

    • weakCompareAndSetAcquire

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

      即使见证值与期望值匹配，此操作也可能出现故障（通常是由于内存争用）。

      方法签名形式为(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)的签名多态参数列表，使用varargs静态表示。
      返回:
      如果成功则true，否则false，如果见证值与expectedValue不同或此操作出现故障。
      抛出:
      UnsupportedOperationException - 如果对于此VarHandle不支持访问模式。
      WrongMethodTypeException - 如果访问模式类型与调用者的符号类型描述符不匹配。
      ClassCastException - 如果访问模式类型与调用者的符号类型描述符匹配，但引用转换失败。
      参见:

    • weakCompareAndSetRelease

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

      即使见证值与期望值匹配，此操作也可能出现故障（通常是由于内存争用）。

      方法签名形式为(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)的签名多态参数列表，使用varargs静态表示。
      返回:
      如果成功则true，否则false，如果见证值与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)
      原子地将变量的值设置为 newValue，具有 set(java.lang.Object...) 的内存语义，并返回变量的先前值，如使用 getAcquire(java.lang.Object...) 的内存语义访问。

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

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

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

    • getAndSetRelease

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

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

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

      参数:
      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 的调用点处的符号类型描述符必须与调用 accessModeType(VarHandle.AccessMode.GET_AND_ADD) 在此VarHandle上的结果匹配。

      参数:
      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 的调用点处的符号类型描述符必须与调用 accessModeType(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE) 在此VarHandle上的结果匹配。

      参数:
      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 的调用点处的符号类型描述符必须与调用 accessModeType(VarHandle.AccessMode.GET_AND_ADD_RELEASE) 在此VarHandle上的结果匹配。

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

    • getAndBitwiseOr

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

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

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

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

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

    • getAndBitwiseOrAcquire

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

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

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

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

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

    • getAndBitwiseOrRelease

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

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

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

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

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

    • getAndBitwiseAnd

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

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

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

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

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

    • getAndBitwiseAndAcquire

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

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

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

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

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

    • getAndBitwiseAndRelease

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

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

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

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

      Parameters:
      args - the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask) , statically represented using varargs.
      Returns:
      the signature-polymorphic result that is the previous value of the variable , statically represented using Object.
      Throws:
      UnsupportedOperationException - if the access mode is unsupported for this VarHandle.
      WrongMethodTypeException - if the access mode type does not match the caller's symbolic type descriptor.
      ClassCastException - if the access mode type matches the caller's symbolic type descriptor, but a reference cast fails.
      See Also:

    • getAndBitwiseXor

      public final Object getAndBitwiseXor(Object... args)
      Atomically sets the value of a variable to the result of bitwise XOR between the variable's current value and the mask with the memory semantics of setVolatile(java.lang.Object...) and returns the variable's previous value, as accessed with the memory semantics of getVolatile(java.lang.Object...).

      If the variable type is the non-integral boolean type then a logical XOR is performed instead of a bitwise XOR.

      The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T.

      The symbolic type descriptor at the call site of getAndBitwiseXor must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR) on this VarHandle.

      Parameters:
      args - the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask) , statically represented using varargs.
      Returns:
      the signature-polymorphic result that is the previous value of the variable , statically represented using Object.
      Throws:
      UnsupportedOperationException - if the access mode is unsupported for this VarHandle.
      WrongMethodTypeException - if the access mode type does not match the caller's symbolic type descriptor.
      ClassCastException - if the access mode type matches the caller's symbolic type descriptor, but a reference cast fails.
      See Also:

    • getAndBitwiseXorAcquire

      public final Object getAndBitwiseXorAcquire(Object... args)
      Atomically sets the value of a variable to the result of bitwise XOR between the variable's current value and the mask with the memory semantics of set(java.lang.Object...) and returns the variable's previous value, as accessed with the memory semantics of getAcquire(java.lang.Object...).

      If the variable type is the non-integral boolean type then a logical XOR is performed instead of a bitwise XOR.

      The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T.

      The symbolic type descriptor at the call site of getAndBitwiseXorAcquire must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE) on this VarHandle.

      Parameters:
      args - the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask) , statically represented using varargs.
      Returns:
      the signature-polymorphic result that is the previous value of the variable , statically represented using Object.
      Throws:
      UnsupportedOperationException - if the access mode is unsupported for this VarHandle.
      WrongMethodTypeException - if the access mode type does not match the caller's symbolic type descriptor.
      ClassCastException - if the access mode type matches the caller's symbolic type descriptor, but a reference cast fails.
      See Also:

    • getAndBitwiseXorRelease

      public final Object getAndBitwiseXorRelease(Object... args)
      Atomically sets the value of a variable to the result of bitwise XOR between the variable's current value and the mask with the memory semantics of setRelease(java.lang.Object...) and returns the variable's previous value, as accessed with the memory semantics of get(java.lang.Object...).

      If the variable type is the non-integral boolean type then a logical XOR is performed instead of a bitwise XOR.

      The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T.

      The symbolic type descriptor at the call site of getAndBitwiseXorRelease must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE) on this VarHandle.

      Parameters:
      args - the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask) , statically represented using varargs.
      Returns:
      the signature-polymorphic result that is the previous value of the variable , statically represented using Object.
      Throws:
      UnsupportedOperationException - if the access mode is unsupported for this VarHandle.
      WrongMethodTypeException - if the access mode type does not match the caller's symbolic type descriptor.
      ClassCastException - if the access mode type matches the caller's symbolic type descriptor, but a reference cast fails.
      See Also:

    • withInvokeExactBehavior

      public abstract VarHandle withInvokeExactBehavior()
      Returns a VarHandle, with access to the same variable(s) as this VarHandle, but whose invocation behavior of access mode methods is adjusted to invoke-exact behavior.

      If this VarHandle already has invoke-exact behavior this VarHandle is returned.

      Invoking hasInvokeExactBehavior() on the returned var handle is guaranteed to return true.

      API Note:
      Invoke-exact behavior guarantees that upon invocation of an access mode method the types and arity of the arguments must match the access mode type, otherwise a WrongMethodTypeException is thrown.
      Returns:
      a VarHandle with invoke-exact behavior
      Since:
      16
      See Also:

    • withInvokeBehavior

      public abstract VarHandle withInvokeBehavior()
      Returns a VarHandle, with access to the same variable(s) as this VarHandle, but whose invocation behavior of access mode methods is adjusted to invoke behavior.

      If this VarHandle already has invoke behavior this VarHandle is returned.

      Invoking hasInvokeExactBehavior() on the returned var handle is guaranteed to return false.

      Returns:
      a VarHandle with invoke behavior
      Since:
      16
      See Also:

    • toString

      public final String toString()
      Returns a compact textual description of this VarHandle, including the type of variable described, and a description of its coordinates.
      Overrides:
      toString in class Object
      Returns:
      A compact textual description of this VarHandle

    • varType

      public Class<?> varType()
      Returns the variable type of variables referenced by this VarHandle.
      Returns:
      the variable type of variables referenced by this VarHandle

    • coordinateTypes

      public List<Class<?>> coordinateTypes()
      Returns the coordinate types for this VarHandle.
      Returns:
      the coordinate types for this VarHandle. The returned list is unmodifiable

    • accessModeType

      public final MethodType accessModeType(VarHandle.AccessMode accessMode)
      Obtains the access mode type for this VarHandle and a given access mode.

      The access mode type's parameter types will consist of a prefix that is the coordinate types of this VarHandle followed by further types as defined by the access mode method. The access mode type's return type is defined by the return type of the access mode method.

      Parameters:
      accessMode - the access mode, corresponding to the signature-polymorphic method of the same name
      Returns:
      the access mode type for the given access mode

    • isAccessModeSupported

      public 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，如果无法构造则返回一个空的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()
      确保栅栏之前的存储不会与栅栏之后的存储重新排序。