Constable
public abstract sealed class VarHandle extends Object implements Constable
VarHandles are immutable and have no visible state. VarHandles cannot be subclassed by the user.
A VarHandle has:
variable type
T, the type of every variable referenced by this VarHandle; and coordinate types
CT1, CT2, ..., CTn
, the types of coordinate expressions that jointly locate a variable referenced by this VarHandle. Class
objects. The list of coordinate types may be empty. Factory methods that produce or lookup
VarHandle instances document the supported variable type and the list of coordinate types.
Each access mode is associated with one access mode method, a signature polymorphic method named for the access mode. When an access mode method is invoked on a VarHandle instance, the initial arguments to the invocation are coordinate expressions that indicate in precisely which object the variable is to be accessed. Trailing arguments to the invocation represent values of importance to the access mode. For example, the various compare-and-set or compare-and-exchange access modes require two trailing arguments for the variable's expected value and new value.
The arity and types of arguments to the invocation of an access mode method are not checked statically. Instead, each access mode method specifies an access mode type
, represented as an instance of MethodType
, that serves as a kind of method signature against which the arguments are checked dynamically. An access mode type gives formal parameter types in terms of the coordinate types of a VarHandle instance and the types for values of importance to the access mode. An access mode type also gives a return type, often in terms of the variable type of a VarHandle instance. When an access mode method is invoked on a VarHandle instance, the symbolic type descriptor at the call site, the run time types of arguments to the invocation, and the run time type of the return value, must match the types given in the access mode type. A runtime exception will be thrown if the match fails. For example, the access mode method compareAndSet(java.lang.Object...)
specifies that if its receiver is a VarHandle instance with coordinate types CT1, ..., CTn
and variable type T
, then its access mode type is (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean
. Suppose that a VarHandle instance can access array elements, and that its coordinate types are String[]
and int
while its variable type is String
. The access mode type for compareAndSet
on this VarHandle instance would be (String[] c1, int c2, String expectedValue, String newValue)boolean
. Such a VarHandle instance may be produced by the array factory method
and access array elements as follows:
String[] sa = ...
VarHandle avh = MethodHandles.arrayElementVarHandle(String[].class);
boolean r = avh.compareAndSet(sa, 10, "expected", "new");
Access modes control atomicity and consistency properties. Plain read (get
) and write (set
) accesses are guaranteed to be bitwise atomic only for references and for primitive values of at most 32 bits, and impose no observable ordering constraints with respect to threads other than the executing thread. Opaque operations are bitwise atomic and coherently ordered with respect to accesses to the same variable. In addition to obeying Opaque properties, Acquire mode reads and their subsequent accesses are ordered after matching Release mode writes and their previous accesses. In addition to obeying Acquire and Release properties, all Volatile operations are totally ordered with respect to each other.
Access modes are grouped into the following categories:
get
, getVolatile
, getAcquire
, getOpaque
. set
, setVolatile
, setRelease
, setOpaque
. compareAndSet
, weakCompareAndSetPlain
, weakCompareAndSet
, weakCompareAndSetAcquire
, weakCompareAndSetRelease
, compareAndExchangeAcquire
, compareAndExchange
, compareAndExchangeRelease
, getAndSet
, getAndSetAcquire
, getAndSetRelease
. getAndAdd
, getAndAddAcquire
, getAndAddRelease
, getAndBitwiseOr
, getAndBitwiseOrAcquire
, getAndBitwiseOrRelease
, getAndBitwiseAnd
, getAndBitwiseAndAcquire
, getAndBitwiseAndRelease
, getAndBitwiseXor
, getAndBitwiseXorAcquire
, getAndBitwiseXorRelease
. Factory methods that produce or lookup
VarHandle instances document the set of access modes that are supported, which may also include documenting restrictions based on the variable type and whether a variable is read-only. If an access mode is not supported then the corresponding access mode method will on invocation throw an UnsupportedOperationException
. Factory methods should document any additional undeclared exceptions that may be thrown by access mode methods. The get
access mode is supported for all VarHandle instances and the corresponding method never throws UnsupportedOperationException
. If a VarHandle references a read-only variable (for example a final
field) then write, atomic update, numeric atomic update, and bitwise atomic update access modes are not supported and corresponding methods throw UnsupportedOperationException
. Read/write access modes (if supported), with the exception of get
and set
, provide atomic access for reference types and all primitive types. Unless stated otherwise in the documentation of a factory method, the access modes get
and set
(if supported) provide atomic access for reference types and all primitives types, with the exception of long
and double
on 32-bit platforms.
Access modes will override any memory ordering effects specified at the declaration site of a variable. For example, a VarHandle accessing a field using the get
access mode will access the field as specified by its access mode even if that field is declared volatile
. When mixed access is performed extreme care should be taken since the Java Memory Model may permit surprising results.
In addition to supporting access to variables under various access modes, a set of static methods, referred to as memory fence methods, is also provided for fine-grained control of memory ordering. The Java Language Specification permits other threads to observe operations as if they were executed in orders different than are apparent in program source code, subject to constraints arising, for example, from the use of locks, volatile
fields or VarHandles. The static methods, fullFence
, acquireFence
, releaseFence
, loadLoadFence
and storeStoreFence
, can also be used to impose constraints. Their specifications, as is the case for certain access modes, are phrased in terms of the lack of "reorderings" -- observable ordering effects that might otherwise occur if the fence was not present. More precise phrasing of the specification of access mode methods and memory fence methods may accompany future updates of the Java Language Specification.
Object
arguments and Object
return types (if the return type is polymorphic), but they have an additional quality called signature polymorphism which connects this freedom of invocation directly to the JVM execution stack. As is usual with virtual methods, source-level calls to access mode methods compile to an invokevirtual
instruction. More unusually, the compiler must record the actual argument types, and may not perform method invocation conversions on the arguments. Instead, it must generate instructions to push them on the stack according to their own unconverted types. The VarHandle object itself will be pushed on the stack before the arguments. The compiler then generates an invokevirtual
instruction that invokes the access mode method with a symbolic type descriptor which describes the argument and return types.
To issue a complete symbolic type descriptor, the compiler must also determine the return type (if polymorphic). This is based on a cast on the method invocation expression, if there is one, or else Object
if the invocation is an expression, or else void
if the invocation is a statement. The cast may be to a primitive type (but not void
).
As a corner case, an uncasted null
argument is given a symbolic type descriptor of java.lang.Void
. The ambiguity with the type Void
is harmless, since there are no references of type Void
except the null reference.
invokevirtual
instruction is executed it is linked by symbolically resolving the names in the instruction and verifying that the method call is statically legal. This also holds for calls to access mode methods. In this case, the symbolic type descriptor emitted by the compiler is checked for correct syntax, and names it contains are resolved. Thus, an invokevirtual
instruction which invokes an access mode method will always link, as long as the symbolic type descriptor is syntactically well-formed and the types exist. When the invokevirtual
is executed after linking, the receiving VarHandle's access mode type is first checked by the JVM to ensure that it matches the symbolic type descriptor. If the type match fails, it means that the access mode method which the caller is invoking is not present on the individual VarHandle being invoked.
Invocation of an access mode method behaves, by default, as if an invocation of MethodHandle.invoke(java.lang.Object...)
, where the receiving method handle accepts the VarHandle instance as the leading argument. More specifically, the following, where {access-mode}
corresponds to the access mode method name:
VarHandle vh = ..
R r = (R) vh.{access-mode}(p1, p2, ..., pN);
behaves as if:
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)
(modulo access mode methods do not declare throwing of Throwable
). This is equivalent to:
MethodHandle mh = MethodHandles.lookup().findVirtual(
VarHandle.class,
"{access-mode}",
MethodType.methodType(R, p1, p2, ..., pN));
R r = (R) mh.invokeExact(vh, p1, p2, ..., pN)
where the desired method type is the symbolic type descriptor and a MethodHandle.invokeExact(java.lang.Object...)
is performed, since before invocation of the target, the handle will apply reference casts as necessary and box, unbox, or widen primitive values, as if by asType
(see also MethodHandles.varHandleInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType)
). More concisely, such behavior is equivalent to:
VarHandle vh = ..
VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
MethodHandle mh = vh.toMethodHandle(am);
R r = (R) mh.invoke(p1, p2, ..., pN)
Where, in this case, the method handle is bound to the VarHandle instance. A VarHandle's invocation behavior can be adjusted (see withInvokeExactBehavior()
) such that invocation of an access mode method behaves as if invocation of MethodHandle.invokeExact(java.lang.Object...)
, where the receiving method handle accepts the VarHandle instance as the leading argument. More specifically, the following, where {access-mode}
corresponds to the access mode method name:
VarHandle vh = ..
R r = (R) vh.{access-mode}(p1, p2, ..., pN);
behaves as if:
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)
(modulo access mode methods do not declare throwing of Throwable
). More concisely, such behavior is equivalent to:
VarHandle vh = ..
VarHandle.AccessMode am = VarHandle.AccessMode.valueFromMethodName("{access-mode}");
MethodHandle mh = vh.toMethodHandle(am);
R r = (R) mh.invokeExact(p1, p2, ..., pN)
Where, in this case, the method handle is bound to the VarHandle instance. WrongMethodTypeException
. Thus, an access mode type mismatch which might show up as a linkage error in a statically typed program can show up as a dynamic WrongMethodTypeException
in a program which uses VarHandles.
Because access mode types contain "live" Class
objects, method type matching takes into account both type names and class loaders. Thus, even if a VarHandle VH
is created in one class loader L1
and used in another L2
, VarHandle access mode method calls are type-safe, because the caller's symbolic type descriptor, as resolved in L2
, is matched against the original callee method's symbolic type descriptor, as resolved in L1
. The resolution in L1
happens when VH
is created and its access mode types are assigned, while the resolution in L2
happens when the invokevirtual
instruction is linked.
Apart from type descriptor checks, a VarHandles's capability to access its variables is unrestricted. If a VarHandle is formed on a non-public variable by a class that has access to that variable, the resulting VarHandle can be used in any place by any caller who receives a reference to it.
Unlike with the Core Reflection API, where access is checked every time a reflective method is invoked, VarHandle access checking is performed when the VarHandle is created. Thus, VarHandles to non-public variables, or to variables in non-public classes, should generally be kept secret. They should not be passed to untrusted code unless their use from the untrusted code would be harmless.
MethodHandles.Lookup
. For example, a VarHandle for a non-static field can be obtained from Lookup.findVarHandle
. There is also a conversion method from Core Reflection API objects, Lookup.unreflectVarHandle
. Access to protected field members is restricted to receivers only of the accessing class, or one of its subclasses, and the accessing class must in turn be a subclass (or package sibling) of the protected member's defining class. If a VarHandle refers to a protected non-static field of a declaring class outside the current package, the receiver argument will be narrowed to the type of the accessing class.
Lookup
API, any field represented by a Core Reflection API object can be converted to a behaviorally equivalent VarHandle. For example, a reflective Field
can be converted to a VarHandle using Lookup.unreflectVarHandle
. The resulting VarHandles generally provide more direct and efficient access to the underlying fields. As a special case, when the Core Reflection API is used to view the signature polymorphic access mode methods in this class, they appear as ordinary non-polymorphic methods. Their reflective appearance, as viewed by Class.getDeclaredMethod
, is unaffected by their special status in this API. For example, Method.getModifiers
will report exactly those modifier bits required for any similarly declared method, including in this case native
and varargs
bits.
As with any reflected method, these methods (when reflected) may be invoked directly via java.lang.reflect.Method.invoke
, via JNI, or indirectly via Lookup.unreflect
. However, such reflective calls do not result in access mode method invocations. Such a call, if passed the required argument (a single one, of type Object[]
), will ignore the argument and will throw an UnsupportedOperationException
.
Since invokevirtual
instructions can natively invoke VarHandle access mode methods under any symbolic type descriptor, this reflective view conflicts with the normal presentation of these methods via bytecodes. Thus, these native methods, when reflectively viewed by Class.getDeclaredMethod
, may be regarded as placeholders only.
In order to obtain an invoker method for a particular access mode type, use MethodHandles.varHandleExactInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType)
or MethodHandles.varHandleInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType)
. The Lookup.findVirtual
API is also able to return a method handle to call an access mode method for any specified access mode type and is equivalent in behavior to MethodHandles.varHandleInvoker(java.lang.invoke.VarHandle.AccessMode, java.lang.invoke.MethodType)
.
invokevirtual
instruction.Modifier and Type | Class | Description |
---|---|---|
static enum |
VarHandle.AccessMode |
The set of access modes that specify how a variable, referenced by a VarHandle, is accessed. |
static final class |
VarHandle.VarHandleDesc |
A nominal descriptor for a VarHandle constant. |
Modifier and Type | Method | Description |
---|---|---|
final MethodType |
accessModeType |
Obtains the access mode type for this VarHandle and a given access mode. |
static void |
acquireFence() |
Ensures that loads before the fence will not be reordered with loads and stores after the fence. |
final Object |
compareAndExchange |
Atomically sets the value of a variable to the newValue with the memory semantics of setVolatile(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of getVolatile(java.lang.Object...) . |
final Object |
compareAndExchangeAcquire |
Atomically sets the value of a variable to the newValue with the memory semantics of set(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of getAcquire(java.lang.Object...) . |
final Object |
compareAndExchangeRelease |
Atomically sets the value of a variable to the newValue with the memory semantics of setRelease(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of get(java.lang.Object...) . |
final boolean |
compareAndSet |
Atomically sets the value of a variable to the newValue with the memory semantics of setVolatile(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of getVolatile(java.lang.Object...) . |
List |
coordinateTypes() |
Returns the coordinate types for this VarHandle. |
Optional |
describeConstable() |
Return a nominal descriptor for this instance, if one can be constructed, or an empty Optional if one cannot be. |
static void |
fullFence() |
Ensures that loads and stores before the fence will not be reordered with loads and stores after the fence. |
final Object |
get |
Returns the value of a variable, with memory semantics of reading as if the variable was declared non- volatile . |
final Object |
getAcquire |
Returns the value of a variable, and ensures that subsequent loads and stores are not reordered before this access. |
final Object |
getAndAdd |
Atomically adds the value to the current value of a variable 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...) . |
final Object |
getAndAddAcquire |
Atomically adds the value to the current value of a variable 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...) . |
final Object |
getAndAddRelease |
Atomically adds the value to the current value of a variable 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...) . |
final Object |
getAndBitwiseAnd |
Atomically sets the value of a variable to the result of bitwise AND 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...) . |
final Object |
getAndBitwiseAndAcquire |
Atomically sets the value of a variable to the result of bitwise AND 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...) . |
final Object |
getAndBitwiseAndRelease |
Atomically sets the value of a variable to the result of bitwise AND 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...) . |
final Object |
getAndBitwiseOr |
Atomically sets the value of a variable to the result of bitwise OR 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...) . |
final Object |
getAndBitwiseOrAcquire |
Atomically sets the value of a variable to the result of bitwise OR 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...) . |
final Object |
getAndBitwiseOrRelease |
Atomically sets the value of a variable to the result of bitwise OR 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...) . |
final Object |
getAndBitwiseXor |
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...) . |
final Object |
getAndBitwiseXorAcquire |
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...) . |
final Object |
getAndBitwiseXorRelease |
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...) . |
final Object |
getAndSet |
Atomically sets the value of a variable to the newValue 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...) . |
final Object |
getAndSetAcquire |
Atomically sets the value of a variable to the newValue 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...) . |
final Object |
getAndSetRelease |
Atomically sets the value of a variable to the newValue 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...) . |
final Object |
getOpaque |
Returns the value of a variable, accessed in program order, but with no assurance of memory ordering effects with respect to other threads. |
final Object |
getVolatile |
Returns the value of a variable, with memory semantics of reading as if the variable was declared volatile . |
boolean |
hasInvokeExactBehavior() |
Returns true if this VarHandle has invoke-exact behavior. |
boolean |
isAccessModeSupported |
Returns true if the given access mode is supported, otherwise false . |
static void |
loadLoadFence() |
Ensures that loads before the fence will not be reordered with loads after the fence. |
static void |
releaseFence() |
Ensures that loads and stores before the fence will not be reordered with stores after the fence. |
final void |
set |
Sets the value of a variable to the newValue , with memory semantics of setting as if the variable was declared non-volatile and non-final . |
final void |
setOpaque |
Sets the value of a variable to the newValue , in program order, but with no assurance of memory ordering effects with respect to other threads. |
final void |
setRelease |
Sets the value of a variable to the newValue , and ensures that prior loads and stores are not reordered after this access. |
final void |
setVolatile |
Sets the value of a variable to the newValue , with memory semantics of setting as if the variable was declared volatile . |
static void |
storeStoreFence() |
Ensures that stores before the fence will not be reordered with stores after the fence. |
MethodHandle |
toMethodHandle |
Obtains a method handle bound to this VarHandle and the given access mode. |
final String |
toString() |
Returns a compact textual description of this VarHandle, including the type of variable described, and a description of its coordinates. |
Class |
varType() |
Returns the variable type of variables referenced by this VarHandle. |
final boolean |
weakCompareAndSet |
Possibly atomically sets the value of a variable to the newValue with the memory semantics of setVolatile(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of getVolatile(java.lang.Object...) . |
final boolean |
weakCompareAndSetAcquire |
Possibly atomically sets the value of a variable to the newValue with the semantics of set(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of getAcquire(java.lang.Object...) . |
final boolean |
weakCompareAndSetPlain |
Possibly atomically sets the value of a variable to the newValue with the semantics of set(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of get(java.lang.Object...) . |
final boolean |
weakCompareAndSetRelease |
Possibly atomically sets the value of a variable to the newValue with the semantics of setRelease(java.lang.Object...) if the variable's current value, referred to as the witness value, == the expectedValue , as accessed with the memory semantics of get(java.lang.Object...) . |
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. |
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. |
public boolean hasInvokeExactBehavior()
true
if this VarHandle has invoke-exact behavior.true
if this VarHandle has invoke-exact behavior.public final Object get(Object... args)
volatile
. Commonly referred to as plain read access. The method signature is of the form (CT1 ct1, ..., CTn ctn)T
.
The symbolic type descriptor at the call site of get
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET)
on this VarHandle.
This access mode is supported by all VarHandle instances and never throws UnsupportedOperationException
.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn)
, statically represented using varargs.Object
.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.public final void set(Object... args)
newValue
, with memory semantics of setting as if the variable was declared non-volatile
and non-final
. Commonly referred to as plain write access. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)void
The symbolic type descriptor at the call site of set
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.SET)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.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.public final Object getVolatile(Object... args)
volatile
. The method signature is of the form (CT1 ct1, ..., CTn ctn)T
.
The symbolic type descriptor at the call site of getVolatile
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_VOLATILE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn)
, statically represented using varargs.Object
.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.public final void setVolatile(Object... args)
newValue
, with memory semantics of setting as if the variable was declared volatile
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)void
.
The symbolic type descriptor at the call site of setVolatile
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.SET_VOLATILE)
on this VarHandle.
memory_order_seq_cst
.args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.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.public final Object getOpaque(Object... args)
The method signature is of the form (CT1 ct1, ..., CTn ctn)T
.
The symbolic type descriptor at the call site of getOpaque
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_OPAQUE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn)
, statically represented using varargs.Object
.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.public final void setOpaque(Object... args)
newValue
, in program order, but with no assurance of memory ordering effects with respect to other threads. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)void
.
The symbolic type descriptor at the call site of setOpaque
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.SET_OPAQUE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.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.public final Object getAcquire(Object... args)
The method signature is of the form (CT1 ct1, ..., CTn ctn)T
.
The symbolic type descriptor at the call site of getAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_ACQUIRE)
on this VarHandle.
memory_order_acquire
ordering.args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn)
, statically represented using varargs.Object
.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.public final void setRelease(Object... args)
newValue
, and ensures that prior loads and stores are not reordered after this access. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)void
.
The symbolic type descriptor at the call site of setRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.SET_RELEASE)
on this VarHandle.
memory_order_release
ordering.args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.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.public final boolean compareAndSet(Object... args)
newValue
with the memory semantics of setVolatile(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of getVolatile(java.lang.Object...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean
.
The symbolic type descriptor at the call site of
compareAndSet
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.COMPARE_AND_SET)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.true
if successful, otherwise false
if the witness value was not the same as the expectedValue
.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.public final Object compareAndExchange(Object... args)
newValue
with the memory semantics of setVolatile(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of getVolatile(java.lang.Object...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T
.
The symbolic type descriptor at the call site of
compareAndExchange
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.expectedValue
if successful , statically represented using Object
.UnsupportedOperationException
- if the access mode is unsupported for this VarHandle.WrongMethodTypeException
- if the access mode type is not compatible with the caller's symbolic type descriptor.ClassCastException
- if the access mode type is compatible with the caller's symbolic type descriptor, but a reference cast fails.public final Object compareAndExchangeAcquire(Object... args)
newValue
with the memory semantics of set(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of getAcquire(java.lang.Object...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T
.
The symbolic type descriptor at the call site of
compareAndExchangeAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.expectedValue
if successful , statically represented using Object
.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.public final Object compareAndExchangeRelease(Object... args)
newValue
with the memory semantics of setRelease(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of get(java.lang.Object...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T
.
The symbolic type descriptor at the call site of
compareAndExchangeRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.expectedValue
if successful , statically represented using Object
.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.public final boolean weakCompareAndSetPlain(Object... args)
newValue
with the semantics of set(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of get(java.lang.Object...)
. This operation may fail spuriously (typically, due to memory contention) even if the witness value does match the expected value.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean
.
The symbolic type descriptor at the call site of
weakCompareAndSetPlain
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.true
if successful, otherwise false
if the witness value was not the same as the expectedValue
or if this operation spuriously failed.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.public final boolean weakCompareAndSet(Object... args)
newValue
with the memory semantics of setVolatile(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of getVolatile(java.lang.Object...)
. This operation may fail spuriously (typically, due to memory contention) even if the witness value does match the expected value.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean
.
The symbolic type descriptor at the call site of
weakCompareAndSet
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.true
if successful, otherwise false
if the witness value was not the same as the expectedValue
or if this operation spuriously failed.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.public final boolean weakCompareAndSetAcquire(Object... args)
newValue
with the semantics of set(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of getAcquire(java.lang.Object...)
. This operation may fail spuriously (typically, due to memory contention) even if the witness value does match the expected value.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean
.
The symbolic type descriptor at the call site of
weakCompareAndSetAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.true
if successful, otherwise false
if the witness value was not the same as the expectedValue
or if this operation spuriously failed.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.public final boolean weakCompareAndSetRelease(Object... args)
newValue
with the semantics of setRelease(java.lang.Object...)
if the variable's current value, referred to as the witness value, ==
the expectedValue
, as accessed with the memory semantics of get(java.lang.Object...)
. This operation may fail spuriously (typically, due to memory contention) even if the witness value does match the expected value.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean
.
The symbolic type descriptor at the call site of
weakCompareAndSetRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)
, statically represented using varargs.true
if successful, otherwise false
if the witness value was not the same as the expectedValue
or if this operation spuriously failed.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.public final Object getAndSet(Object... args)
newValue
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...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)T
.
The symbolic type descriptor at the call site of getAndSet
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_SET)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.Object
.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.public final Object getAndSetAcquire(Object... args)
newValue
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...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)T
.
The symbolic type descriptor at the call site of getAndSetAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_SET_ACQUIRE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.Object
.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.public final Object getAndSetRelease(Object... args)
newValue
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...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T newValue)T
.
The symbolic type descriptor at the call site of getAndSetRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_SET_RELEASE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T newValue)
, statically represented using varargs.Object
.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.public final Object getAndAdd(Object... args)
value
to the current value of a variable 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...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T value)T
.
The symbolic type descriptor at the call site of getAndAdd
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_ADD)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T value)
, statically represented using varargs.Object
.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.public final Object getAndAddAcquire(Object... args)
value
to the current value of a variable 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...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T value)T
.
The symbolic type descriptor at the call site of getAndAddAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T value)
, statically represented using varargs.Object
.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.public final Object getAndAddRelease(Object... args)
value
to the current value of a variable 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...)
. The method signature is of the form (CT1 ct1, ..., CTn ctn, T value)T
.
The symbolic type descriptor at the call site of getAndAddRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_ADD_RELEASE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T value)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseOr(Object... args)
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 OR is performed instead of a bitwise OR.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T
.
The symbolic type descriptor at the call site of getAndBitwiseOr
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseOrAcquire(Object... args)
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 OR is performed instead of a bitwise OR.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T
.
The symbolic type descriptor at the call site of getAndBitwiseOrAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseOrRelease(Object... args)
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 OR is performed instead of a bitwise OR.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T
.
The symbolic type descriptor at the call site of getAndBitwiseOrRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseAnd(Object... args)
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 AND is performed instead of a bitwise AND.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T
.
The symbolic type descriptor at the call site of getAndBitwiseAnd
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseAndAcquire(Object... args)
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 AND is performed instead of a bitwise AND.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T
.
The symbolic type descriptor at the call site of getAndBitwiseAndAcquire
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseAndRelease(Object... args)
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 AND is performed instead of a bitwise AND.
The method signature is of the form (CT1 ct1, ..., CTn ctn, T mask)T
.
The symbolic type descriptor at the call site of getAndBitwiseAndRelease
must match the access mode type that is the result of calling accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE)
on this VarHandle.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseXor(Object... args)
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.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseXorAcquire(Object... args)
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.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public final Object getAndBitwiseXorRelease(Object... args)
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.
args
- the signature-polymorphic parameter list of the form (CT1 ct1, ..., CTn ctn, T mask)
, statically represented using varargs.Object
.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.public abstract VarHandle withInvokeExactBehavior()
If this VarHandle already has invoke-exact behavior this VarHandle is returned.
Invoking hasInvokeExactBehavior()
on the returned var handle is guaranteed to return true
.
access mode type
, otherwise a WrongMethodTypeException
is thrown.public abstract VarHandle withInvokeBehavior()
If this VarHandle already has invoke behavior this VarHandle is returned.
Invoking hasInvokeExactBehavior()
on the returned var handle is guaranteed to return false
.
public final String toString()
public Class<?> varType()
public List<Class<?>> coordinateTypes()
public final MethodType accessModeType(VarHandle.AccessMode accessMode)
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.
accessMode
- the access mode, corresponding to the signature-polymorphic method of the same namepublic boolean isAccessModeSupported(VarHandle.AccessMode accessMode)
true
if the given access mode is supported, otherwise false
. The return of a false
value for a given access mode indicates that an UnsupportedOperationException
is thrown on invocation of the corresponding access mode method.
accessMode
- the access mode, corresponding to the signature-polymorphic method of the same nametrue
if the given access mode is supported, otherwise false
.public MethodHandle toMethodHandle(VarHandle.AccessMode accessMode)
vh
and access mode {access-mode}
, returns a method handle that is equivalent to method handle bmh
in the following code (though it may be more efficient):
MethodHandle mh = MethodHandles.varHandleExactInvoker(
vh.accessModeType(VarHandle.AccessMode.{access-mode}));
MethodHandle bmh = mh.bindTo(vh);
accessMode
- the access mode, corresponding to the signature-polymorphic method of the same namepublic Optional<VarHandle.VarHandleDesc> describeConstable()
Optional
if one cannot be.describeConstable
in interface Constable
Optional
containing the resulting nominal descriptor, or an empty Optional
if one cannot be constructed.public static void fullFence()
atomic_thread_fence(memory_order_seq_cst)
public static void acquireFence()
atomic_thread_fence(memory_order_acquire)
public static void releaseFence()
atomic_thread_fence(memory_order_release)
public static void loadLoadFence()
public static void storeStoreFence()
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/invoke/VarHandle.html