VarHandles are immutable and have no visible state. VarHandles cannot be * subclassed by the user. * *
A VarHandle has: *
Factory methods that produce or {@link java.lang.invoke.MethodHandles.Lookup * 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 {@link #accessModeType(AccessMode) access mode type}, * represented as an instance of {@link 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 {@link #compareAndSet} specifies that if * its receiver is a VarHandle instance with coordinate types * {@code CT1, ..., CTn} and variable type {@code T}, then its access mode type * is {@code (CT1 c1, ..., CTn cn, T expectedValue, T newValue)boolean}. * Suppose that a VarHandle instance can access array elements, and that its * coordinate types are {@code String[]} and {@code int} while its variable type * is {@code String}. The access mode type for {@code compareAndSet} on this * VarHandle instance would be * {@code (String[] c1, int c2, String expectedValue, String newValue)boolean}. * Such a VarHandle instance may be produced by the * {@link MethodHandles#arrayElementVarHandle(Class) array factory method} and * access array elements as follows: *
{@code
* 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 ({@code get}) and write ({@code 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: *
Factory methods that produce or {@link java.lang.invoke.MethodHandles.Lookup * 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 {@code UnsupportedOperationException}. Factory methods should document * any additional undeclared exceptions that may be thrown by access mode * methods. * The {@link #get get} access mode is supported for all * VarHandle instances and the corresponding method never throws * {@code UnsupportedOperationException}. * If a VarHandle references a read-only variable (for example a {@code final} * field) then write, atomic update, numeric atomic update, and bitwise atomic * update access modes are not supported and corresponding methods throw * {@code UnsupportedOperationException}. * Read/write access modes (if supported), with the exception of * {@code get} and {@code set}, provide atomic access for * reference types and all primitive types. * Unless stated otherwise in the documentation of a factory method, the access * modes {@code get} and {@code set} (if supported) provide atomic access for * reference types and all primitives types, with the exception of {@code long} * and {@code 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 {@code get} access mode will access the field as * specified by its access mode even if that field is declared * {@code 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, {@code volatile} fields or VarHandles. The static methods, * {@link #fullFence fullFence}, {@link #acquireFence acquireFence}, * {@link #releaseFence releaseFence}, {@link #loadLoadFence loadLoadFence} and * {@link #storeStoreFence 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. * *
* As is usual with virtual methods, source-level calls to access mode methods * compile to an {@code 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 {@code 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 {@code Object} if the * invocation is an expression, or else {@code void} if the invocation is a * statement. The cast may be to a primitive type (but not {@code void}). *
* As a corner case, an uncasted {@code null} argument is given a symbolic type * descriptor of {@code java.lang.Void}. The ambiguity with the type * {@code Void} is harmless, since there are no references of type {@code Void} * except the null reference. * * *
* When the {@code 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 as if an invocation of * {@link MethodHandle#invoke}, where the receiving method handle accepts the * VarHandle instance as the leading argument. More specifically, the * following, where {@code {access-mode}} corresponds to the access mode method * name: *
{@code
* VarHandle vh = ..
* R r = (R) vh.{access-mode}(p1, p2, ..., pN);
* }
* behaves as if:
* {@code
* 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 {@code Throwable}).
* This is equivalent to:
* {@code
* 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
* {@link MethodHandle#invokeExact} 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 {@link MethodHandle#asType asType} (see also
* {@link MethodHandles#varHandleInvoker}).
*
* More concisely, such behaviour is equivalent to:
* {@code
* 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.
*
*
* * 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 * {@code WrongMethodTypeException} in a program which uses VarHandles. *
* Because access mode types contain "live" {@code Class} objects, method type * matching takes into account both type names and class loaders. * Thus, even if a VarHandle {@code VH} is created in one class loader * {@code L1} and used in another {@code L2}, VarHandle access mode method * calls are type-safe, because the caller's symbolic type descriptor, as * resolved in {@code L2}, is matched against the original callee method's * symbolic type descriptor, as resolved in {@code L1}. The resolution in * {@code L1} happens when {@code VH} is created and its access mode types are * assigned, while the resolution in {@code L2} happens when the * {@code invokevirtual} instruction is linked. *
* Apart from type descriptor checks, a VarHandles's capability to * access it's 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. * * *
* 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. * *
* 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 * {@link java.lang.Class#getDeclaredMethod Class.getDeclaredMethod}, * is unaffected by their special status in this API. * For example, {@link java.lang.reflect.Method#getModifiers * Method.getModifiers} * will report exactly those modifier bits required for any similarly * declared method, including in this case {@code native} and {@code varargs} * bits. *
* As with any reflected method, these methods (when reflected) may be invoked * directly via {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}, * via JNI, or indirectly via * {@link java.lang.invoke.MethodHandles.Lookup#unreflect 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 {@code Object[]}), will ignore the argument and will throw an * {@code UnsupportedOperationException}. *
* Since {@code 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 * {@code Class.getDeclaredMethod}, may be regarded as placeholders only. *
* In order to obtain an invoker method for a particular access mode type, * use {@link java.lang.invoke.MethodHandles#varHandleExactInvoker} or * {@link java.lang.invoke.MethodHandles#varHandleInvoker}. The * {@link java.lang.invoke.MethodHandles.Lookup#findVirtual 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 behaviour to * {@link java.lang.invoke.MethodHandles#varHandleInvoker}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}. * *
The symbolic type descriptor at the call site of {@code get} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET)} on this VarHandle. * *
This access mode is supported by all VarHandle instances and never * throws {@code UnsupportedOperationException}. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn)} * , statically represented using varargs. * @return the signature-polymorphic result that is the value of the * variable * , statically represented using {@code Object}. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object get(Object... args); /** * Sets the value of a variable to the {@code newValue}, with memory * semantics of setting as if the variable was declared non-{@code volatile} * and non-{@code final}. Commonly referred to as plain write access. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void} * *
The symbolic type descriptor at the call site of {@code set} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.SET)} on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate void set(Object... args); // Volatile accessors /** * Returns the value of a variable, with memory semantics of reading as if * the variable was declared {@code volatile}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}. * *
The symbolic type descriptor at the call site of {@code getVolatile} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_VOLATILE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn)} * , statically represented using varargs. * @return the signature-polymorphic result that is the value of the * variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getVolatile(Object... args); /** * Sets the value of a variable to the {@code newValue}, with memory * semantics of setting as if the variable was declared {@code volatile}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}. * *
The symbolic type descriptor at the call site of {@code setVolatile} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.SET_VOLATILE)} on this * VarHandle. * * @apiNote * Ignoring the many semantic differences from C and C++, this method has * memory ordering effects compatible with {@code memory_order_seq_cst}. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate void setVolatile(Object... args); /** * Returns the value of a variable, accessed in program order, but with no * assurance of memory ordering effects with respect to other threads. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}. * *
The symbolic type descriptor at the call site of {@code getOpaque} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_OPAQUE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn)} * , statically represented using varargs. * @return the signature-polymorphic result that is the value of the * variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getOpaque(Object... args); /** * Sets the value of a variable to the {@code newValue}, in program order, * but with no assurance of memory ordering effects with respect to other * threads. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}. * *
The symbolic type descriptor at the call site of {@code setOpaque} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.SET_OPAQUE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate void setOpaque(Object... args); // Lazy accessors /** * Returns the value of a variable, and ensures that subsequent loads and * stores are not reordered before this access. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn)T}. * *
The symbolic type descriptor at the call site of {@code getAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_ACQUIRE)} on this * VarHandle. * * @apiNote * Ignoring the many semantic differences from C and C++, this method has * memory ordering effects compatible with {@code memory_order_acquire} * ordering. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn)} * , statically represented using varargs. * @return the signature-polymorphic result that is the value of the * variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAcquire(Object... args); /** * Sets the value of a variable to the {@code newValue}, and ensures that * prior loads and stores are not reordered after this access. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)void}. * *
The symbolic type descriptor at the call site of {@code setRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.SET_RELEASE)} on this * VarHandle. * * @apiNote * Ignoring the many semantic differences from C and C++, this method has * memory ordering effects compatible with {@code memory_order_release} * ordering. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate void setRelease(Object... args); // Compare and set accessors /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #setVolatile} if the variable's current value, * referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #getVolatile}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}. * *
The symbolic type descriptor at the call site of {@code * compareAndSet} must match the access mode type that is the result of * calling {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_SET)} on * this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return {@code true} if successful, otherwise {@code false} if the * witness value was not the same as the {@code expectedValue}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate boolean compareAndSet(Object... args); /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #setVolatile} if the variable's current value, * referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #getVolatile}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}. * *
The symbolic type descriptor at the call site of {@code * compareAndExchange} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE)} * on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return the signature-polymorphic result that is the witness value, which * will be the same as the {@code expectedValue} if successful * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type is not * compatible with the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type is compatible with the * caller's symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object compareAndExchange(Object... args); /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #set} if the variable's current value, * referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #getAcquire}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}. * *
The symbolic type descriptor at the call site of {@code * compareAndExchangeAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_ACQUIRE)} on * this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return the signature-polymorphic result that is the witness value, which * will be the same as the {@code expectedValue} if successful * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #set(Object...) * @see #getAcquire(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object compareAndExchangeAcquire(Object... args); /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #setRelease} if the variable's current value, * referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #get}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)T}. * *
The symbolic type descriptor at the call site of {@code * compareAndExchangeRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.COMPARE_AND_EXCHANGE_RELEASE)} * on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return the signature-polymorphic result that is the witness value, which * will be the same as the {@code expectedValue} if successful * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setRelease(Object...) * @see #get(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object compareAndExchangeRelease(Object... args); // Weak (spurious failures allowed) /** * Possibly atomically sets the value of a variable to the {@code newValue} * with the semantics of {@link #set} if the variable's current value, * referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #get}. * *
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 {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}. * *
The symbolic type descriptor at the call site of {@code * weakCompareAndSetPlain} must match the access mode type that is the result of * calling {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_PLAIN)} * on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return {@code true} if successful, otherwise {@code false} if the * witness value was not the same as the {@code expectedValue} or if this * operation spuriously failed. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #set(Object...) * @see #get(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate boolean weakCompareAndSetPlain(Object... args); /** * Possibly atomically sets the value of a variable to the {@code newValue} * with the memory semantics of {@link #setVolatile} if the variable's * current value, referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #getVolatile}. * *
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 {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}. * *
The symbolic type descriptor at the call site of {@code * weakCompareAndSet} must match the access mode type that is the * result of calling {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET)} * on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return {@code true} if successful, otherwise {@code false} if the * witness value was not the same as the {@code expectedValue} or if this * operation spuriously failed. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate boolean weakCompareAndSet(Object... args); /** * Possibly atomically sets the value of a variable to the {@code newValue} * with the semantics of {@link #set} if the variable's current value, * referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #getAcquire}. * *
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 {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}. * *
The symbolic type descriptor at the call site of {@code * weakCompareAndSetAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_ACQUIRE)} * on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return {@code true} if successful, otherwise {@code false} if the * witness value was not the same as the {@code expectedValue} or if this * operation spuriously failed. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #set(Object...) * @see #getAcquire(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate boolean weakCompareAndSetAcquire(Object... args); /** * Possibly atomically sets the value of a variable to the {@code newValue} * with the semantics of {@link #setRelease} if the variable's current * value, referred to as the witness value, {@code ==} the * {@code expectedValue}, as accessed with the memory semantics of * {@link #get}. * *
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 {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)boolean}. * *
The symbolic type descriptor at the call site of {@code * weakCompareAndSetRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.WEAK_COMPARE_AND_SET_RELEASE)} * on this VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T expectedValue, T newValue)} * , statically represented using varargs. * @return {@code true} if successful, otherwise {@code false} if the * witness value was not the same as the {@code expectedValue} or if this * operation spuriously failed. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setRelease(Object...) * @see #get(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate boolean weakCompareAndSetRelease(Object... args); /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #setVolatile} and returns the variable's * previous value, as accessed with the memory semantics of * {@link #getVolatile}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}. * *
The symbolic type descriptor at the call site of {@code getAndSet} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_SET)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndSet(Object... args); /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #set} and returns the variable's * previous value, as accessed with the memory semantics of * {@link #getAcquire}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}. * *
The symbolic type descriptor at the call site of {@code getAndSetAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_SET_ACQUIRE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndSetAcquire(Object... args); /** * Atomically sets the value of a variable to the {@code newValue} with the * memory semantics of {@link #setRelease} and returns the variable's * previous value, as accessed with the memory semantics of * {@link #get}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T newValue)T}. * *
The symbolic type descriptor at the call site of {@code getAndSetRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_SET_RELEASE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T newValue)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndSetRelease(Object... args); // Primitive adders // Throw UnsupportedOperationException for refs /** * Atomically adds the {@code value} to the current value of a variable with * the memory semantics of {@link #setVolatile}, and returns the variable's * previous value, as accessed with the memory semantics of * {@link #getVolatile}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}. * *
The symbolic type descriptor at the call site of {@code getAndAdd} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_ADD)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T value)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndAdd(Object... args); /** * Atomically adds the {@code value} to the current value of a variable with * the memory semantics of {@link #set}, and returns the variable's * previous value, as accessed with the memory semantics of * {@link #getAcquire}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}. * *
The symbolic type descriptor at the call site of {@code getAndAddAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_ADD_ACQUIRE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T value)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndAddAcquire(Object... args); /** * Atomically adds the {@code value} to the current value of a variable with * the memory semantics of {@link #setRelease}, and returns the variable's * previous value, as accessed with the memory semantics of * {@link #get}. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T value)T}. * *
The symbolic type descriptor at the call site of {@code getAndAddRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_ADD_RELEASE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T value)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndAddRelease(Object... args); // Bitwise operations // Throw UnsupportedOperationException for refs /** * Atomically sets the value of a variable to the result of * bitwise OR between the variable's current value and the {@code mask} * with the memory semantics of {@link #setVolatile} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #getVolatile}. * *
If the variable type is the non-integral {@code boolean} type then a * logical OR is performed instead of a bitwise OR. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseOr} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndBitwiseOr(Object... args); /** * Atomically sets the value of a variable to the result of * bitwise OR between the variable's current value and the {@code mask} * with the memory semantics of {@link #set} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #getAcquire}. * *
If the variable type is the non-integral {@code boolean} type then a * logical OR is performed instead of a bitwise OR. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseOrAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_ACQUIRE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #set(Object...) * @see #getAcquire(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndBitwiseOrAcquire(Object... args); /** * Atomically sets the value of a variable to the result of * bitwise OR between the variable's current value and the {@code mask} * with the memory semantics of {@link #setRelease} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #get}. * *
If the variable type is the non-integral {@code boolean} type then a * logical OR is performed instead of a bitwise OR. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseOrRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_OR_RELEASE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setRelease(Object...) * @see #get(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndBitwiseOrRelease(Object... args); /** * Atomically sets the value of a variable to the result of * bitwise AND between the variable's current value and the {@code mask} * with the memory semantics of {@link #setVolatile} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #getVolatile}. * *
If the variable type is the non-integral {@code boolean} type then a * logical AND is performed instead of a bitwise AND. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseAnd} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndBitwiseAnd(Object... args); /** * Atomically sets the value of a variable to the result of * bitwise AND between the variable's current value and the {@code mask} * with the memory semantics of {@link #set} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #getAcquire}. * *
If the variable type is the non-integral {@code boolean} type then a * logical AND is performed instead of a bitwise AND. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseAndAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_ACQUIRE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #set(Object...) * @see #getAcquire(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndBitwiseAndAcquire(Object... args); /** * Atomically sets the value of a variable to the result of * bitwise AND between the variable's current value and the {@code mask} * with the memory semantics of {@link #setRelease} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #get}. * *
If the variable type is the non-integral {@code boolean} type then a * logical AND is performed instead of a bitwise AND. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseAndRelease} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_AND_RELEASE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setRelease(Object...) * @see #get(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate Object getAndBitwiseAndRelease(Object... args); /** * Atomically sets the value of a variable to the result of * bitwise XOR between the variable's current value and the {@code mask} * with the memory semantics of {@link #setVolatile} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #getVolatile}. * *
If the variable type is the non-integral {@code boolean} type then a * logical XOR is performed instead of a bitwise XOR. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseXor} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #setVolatile(Object...) * @see #getVolatile(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate 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 {@code mask} * with the memory semantics of {@link #set} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #getAcquire}. * *
If the variable type is the non-integral {@code boolean} type then a * logical XOR is performed instead of a bitwise XOR. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseXorAcquire} * must match the access mode type that is the result of calling * {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_ACQUIRE)} on this * VarHandle. * * @param args the signature-polymorphic parameter list of the form * {@code (CT1 ct1, ..., CTn ctn, T mask)} * , statically represented using varargs. * @return the signature-polymorphic result that is the previous value of * the variable * , statically represented using {@code Object}. * @throws UnsupportedOperationException if the access mode is unsupported * for this VarHandle. * @throws WrongMethodTypeException if the access mode type does not * match the caller's symbolic type descriptor. * @throws ClassCastException if the access mode type matches the caller's * symbolic type descriptor, but a reference cast fails. * @see #set(Object...) * @see #getAcquire(Object...) */ public final native @MethodHandle.PolymorphicSignature @IntrinsicCandidate 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 {@code mask} * with the memory semantics of {@link #setRelease} and returns the * variable's previous value, as accessed with the memory semantics of * {@link #get}. * *
If the variable type is the non-integral {@code boolean} type then a * logical XOR is performed instead of a bitwise XOR. * *
The method signature is of the form {@code (CT1 ct1, ..., CTn ctn, T mask)T}. * *
The symbolic type descriptor at the call site of {@code getAndBitwiseXorRelease}
* must match the access mode type that is the result of calling
* {@code accessModeType(VarHandle.AccessMode.GET_AND_BITWISE_XOR_RELEASE)} on this
* VarHandle.
*
* @param args the signature-polymorphic parameter list of the form
* {@code (CT1 ct1, ..., CTn ctn, T mask)}
* , statically represented using varargs.
* @return the signature-polymorphic result that is the previous value of
* the variable
* , statically represented using {@code Object}.
* @throws UnsupportedOperationException if the access mode is unsupported
* for this VarHandle.
* @throws WrongMethodTypeException if the access mode type does not
* match the caller's symbolic type descriptor.
* @throws ClassCastException if the access mode type matches the caller's
* symbolic type descriptor, but a reference cast fails.
* @see #setRelease(Object...)
* @see #get(Object...)
*/
public final native
@MethodHandle.PolymorphicSignature
@IntrinsicCandidate
Object getAndBitwiseXorRelease(Object... args);
// Android-changed: remove unused return type in AccessType constructor.
enum AccessType {
GET,
SET,
COMPARE_AND_SET,
COMPARE_AND_EXCHANGE,
GET_AND_UPDATE,
// Android-added: Finer grained access types.
// These are used to help categorize the access modes that a VarHandle supports.
GET_AND_UPDATE_BITWISE,
GET_AND_UPDATE_NUMERIC;
MethodType accessModeType(Class receiver, Class value,
Class... intermediate) {
Class[] ps;
int i;
switch (this) {
case GET:
ps = allocateParameters(0, receiver, intermediate);
fillParameters(ps, receiver, intermediate);
return MethodType.methodType(value, ps);
case SET:
ps = allocateParameters(1, receiver, intermediate);
i = fillParameters(ps, receiver, intermediate);
ps[i] = value;
return MethodType.methodType(void.class, ps);
case COMPARE_AND_SET:
ps = allocateParameters(2, receiver, intermediate);
i = fillParameters(ps, receiver, intermediate);
ps[i++] = value;
ps[i] = value;
return MethodType.methodType(boolean.class, ps);
case COMPARE_AND_EXCHANGE:
ps = allocateParameters(2, receiver, intermediate);
i = fillParameters(ps, receiver, intermediate);
ps[i++] = value;
ps[i] = value;
return MethodType.methodType(value, ps);
case GET_AND_UPDATE:
case GET_AND_UPDATE_BITWISE:
case GET_AND_UPDATE_NUMERIC:
ps = allocateParameters(1, receiver, intermediate);
i = fillParameters(ps, receiver, intermediate);
ps[i] = value;
return MethodType.methodType(value, ps);
default:
throw new InternalError("Unknown AccessType");
}
}
private static Class[] allocateParameters(int values,
Class receiver, Class... intermediate) {
int size = ((receiver != null) ? 1 : 0) + intermediate.length + values;
return new Class[size];
}
private static int fillParameters(Class[] ps,
Class receiver, Class... intermediate) {
int i = 0;
if (receiver != null)
ps[i++] = receiver;
for (int j = 0; j < intermediate.length; j++)
ps[i++] = intermediate[j];
return i;
}
}
/**
* The set of access modes that specify how a variable, referenced by a
* VarHandle, is accessed.
*/
public enum AccessMode {
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#get VarHandle.get}
*/
GET("get", AccessType.GET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#set VarHandle.set}
*/
SET("set", AccessType.SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getVolatile VarHandle.getVolatile}
*/
GET_VOLATILE("getVolatile", AccessType.GET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#setVolatile VarHandle.setVolatile}
*/
SET_VOLATILE("setVolatile", AccessType.SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAcquire VarHandle.getAcquire}
*/
GET_ACQUIRE("getAcquire", AccessType.GET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#setRelease VarHandle.setRelease}
*/
SET_RELEASE("setRelease", AccessType.SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getOpaque VarHandle.getOpaque}
*/
GET_OPAQUE("getOpaque", AccessType.GET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#setOpaque VarHandle.setOpaque}
*/
SET_OPAQUE("setOpaque", AccessType.SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#compareAndSet VarHandle.compareAndSet}
*/
COMPARE_AND_SET("compareAndSet", AccessType.COMPARE_AND_SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#compareAndExchange VarHandle.compareAndExchange}
*/
COMPARE_AND_EXCHANGE("compareAndExchange", AccessType.COMPARE_AND_EXCHANGE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#compareAndExchangeAcquire VarHandle.compareAndExchangeAcquire}
*/
COMPARE_AND_EXCHANGE_ACQUIRE("compareAndExchangeAcquire", AccessType.COMPARE_AND_EXCHANGE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#compareAndExchangeRelease VarHandle.compareAndExchangeRelease}
*/
COMPARE_AND_EXCHANGE_RELEASE("compareAndExchangeRelease", AccessType.COMPARE_AND_EXCHANGE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#weakCompareAndSetPlain VarHandle.weakCompareAndSetPlain}
*/
WEAK_COMPARE_AND_SET_PLAIN("weakCompareAndSetPlain", AccessType.COMPARE_AND_SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#weakCompareAndSet VarHandle.weakCompareAndSet}
*/
WEAK_COMPARE_AND_SET("weakCompareAndSet", AccessType.COMPARE_AND_SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#weakCompareAndSetAcquire VarHandle.weakCompareAndSetAcquire}
*/
WEAK_COMPARE_AND_SET_ACQUIRE("weakCompareAndSetAcquire", AccessType.COMPARE_AND_SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#weakCompareAndSetRelease VarHandle.weakCompareAndSetRelease}
*/
WEAK_COMPARE_AND_SET_RELEASE("weakCompareAndSetRelease", AccessType.COMPARE_AND_SET),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndSet VarHandle.getAndSet}
*/
GET_AND_SET("getAndSet", AccessType.GET_AND_UPDATE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndSetAcquire VarHandle.getAndSetAcquire}
*/
GET_AND_SET_ACQUIRE("getAndSetAcquire", AccessType.GET_AND_UPDATE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndSetRelease VarHandle.getAndSetRelease}
*/
GET_AND_SET_RELEASE("getAndSetRelease", AccessType.GET_AND_UPDATE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndAdd VarHandle.getAndAdd}
*/
GET_AND_ADD("getAndAdd", AccessType.GET_AND_UPDATE_NUMERIC),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndAddAcquire VarHandle.getAndAddAcquire}
*/
GET_AND_ADD_ACQUIRE("getAndAddAcquire", AccessType.GET_AND_UPDATE_NUMERIC),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndAddRelease VarHandle.getAndAddRelease}
*/
GET_AND_ADD_RELEASE("getAndAddRelease", AccessType.GET_AND_UPDATE_NUMERIC),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseOr VarHandle.getAndBitwiseOr}
*/
GET_AND_BITWISE_OR("getAndBitwiseOr", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseOrRelease VarHandle.getAndBitwiseOrRelease}
*/
GET_AND_BITWISE_OR_RELEASE("getAndBitwiseOrRelease", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseOrAcquire VarHandle.getAndBitwiseOrAcquire}
*/
GET_AND_BITWISE_OR_ACQUIRE("getAndBitwiseOrAcquire", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseAnd VarHandle.getAndBitwiseAnd}
*/
GET_AND_BITWISE_AND("getAndBitwiseAnd", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseAndRelease VarHandle.getAndBitwiseAndRelease}
*/
GET_AND_BITWISE_AND_RELEASE("getAndBitwiseAndRelease", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseAndAcquire VarHandle.getAndBitwiseAndAcquire}
*/
GET_AND_BITWISE_AND_ACQUIRE("getAndBitwiseAndAcquire", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseXor VarHandle.getAndBitwiseXor}
*/
GET_AND_BITWISE_XOR("getAndBitwiseXor", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseXorRelease VarHandle.getAndBitwiseXorRelease}
*/
GET_AND_BITWISE_XOR_RELEASE("getAndBitwiseXorRelease", AccessType.GET_AND_UPDATE_BITWISE),
/**
* The access mode whose access is specified by the corresponding
* method
* {@link VarHandle#getAndBitwiseXorAcquire VarHandle.getAndBitwiseXorAcquire}
*/
GET_AND_BITWISE_XOR_ACQUIRE("getAndBitwiseXorAcquire", AccessType.GET_AND_UPDATE_BITWISE),
;
static final Map 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.
*
* @param accessMode the access mode, corresponding to the
* signature-polymorphic method of the same name
* @return the access mode type for the given access mode
*/
public final MethodType accessModeType(AccessMode accessMode) {
// BEGIN Android-removed: Relies on internal class that is not part of the
// Android implementation.
/*
TypesAndInvokers tis = getTypesAndInvokers();
MethodType mt = tis.methodType_table[accessMode.at.ordinal()];
if (mt == null) {
mt = tis.methodType_table[accessMode.at.ordinal()] =
accessModeTypeUncached(accessMode);
}
return mt;
*/
// END Android-removed: Relies on internal class that is not part of the
// Android implementation.
// Android-added: alternative implementation.
if (coordinateType1 == null) {
// accessModeType() treats the first argument as the
// receiver and adapts accordingly if it is null.
return accessMode.at.accessModeType(coordinateType0, varType);
} else {
return accessMode.at.accessModeType(coordinateType0, varType, coordinateType1);
}
}
// Android-removed: Not part of the Android implementation.
// abstract MethodType accessModeTypeUncached(AccessMode accessMode);
/**
* Returns {@code true} if the given access mode is supported, otherwise
* {@code false}.
*
* The return of a {@code false} value for a given access mode indicates
* that an {@code UnsupportedOperationException} is thrown on invocation
* of the corresponding access mode method.
*
* @param accessMode the access mode, corresponding to the
* signature-polymorphic method of the same name
* @return {@code true} if the given access mode is supported, otherwise
* {@code false}.
*/
public final boolean isAccessModeSupported(AccessMode accessMode) {
// Android-removed: Refers to unused field vform.
// return AccessMode.getMemberName(accessMode.ordinal(), vform) != null;
// Android-added: use accessModesBitsMask field.
final int testBit = 1 << accessMode.ordinal();
return (accessModesBitMask & testBit) == testBit;
}
/**
* Obtains a method handle bound to this VarHandle and the given access
* mode.
*
* @apiNote This method, for a VarHandle {@code vh} and access mode
* {@code {access-mode}}, returns a method handle that is equivalent to
* method handle {@code bmh} in the following code (though it may be more
* efficient):
* {@code
* MethodHandle mh = MethodHandles.varHandleExactInvoker(
* vh.accessModeType(VarHandle.AccessMode.{access-mode}));
*
* MethodHandle bmh = mh.bindTo(vh);
* }
*
* @param accessMode the access mode, corresponding to the
* signature-polymorphic method of the same name
* @return a method handle bound to this VarHandle and the given access mode
*/
public final MethodHandle toMethodHandle(AccessMode accessMode) {
// BEGIN Android-removed: no vform field in Android implementation.
/*
MemberName mn = AccessMode.getMemberName(accessMode.ordinal(), vform);
if (mn != null) {
MethodHandle mh = getMethodHandle(accessMode.ordinal());
return mh.bindTo(this);
}
else {
// Ensure an UnsupportedOperationException is thrown
return MethodHandles.varHandleInvoker(accessMode, accessModeType(accessMode)).
bindTo(this);
}
*/
// END Android-removed: no vform field in Android implementation.
// Android-added: basic implementation following description in javadoc for this method.
MethodType type = accessModeType(accessMode);
return MethodHandles.varHandleExactInvoker(accessMode, type).bindTo(this);
}
// BEGIN Android-removed: Not used in Android implementation.
/*
@Stable
TypesAndInvokers typesAndInvokers;
static class TypesAndInvokers {
final @Stable
MethodType[] methodType_table =
new MethodType[VarHandle.AccessType.values().length];
final @Stable
MethodHandle[] methodHandle_table =
new MethodHandle[AccessMode.values().length];
}
@ForceInline
private final TypesAndInvokers getTypesAndInvokers() {
TypesAndInvokers tis = typesAndInvokers;
if (tis == null) {
tis = typesAndInvokers = new TypesAndInvokers();
}
return tis;
}
@ForceInline
final MethodHandle getMethodHandle(int mode) {
TypesAndInvokers tis = getTypesAndInvokers();
MethodHandle mh = tis.methodHandle_table[mode];
if (mh == null) {
mh = tis.methodHandle_table[mode] = getMethodHandleUncached(mode);
}
return mh;
}
private final MethodHandle getMethodHandleUncached(int mode) {
MethodType mt = accessModeType(AccessMode.values()[mode]).
insertParameterTypes(0, VarHandle.class);
MemberName mn = vform.getMemberName(mode);
DirectMethodHandle dmh = DirectMethodHandle.make(mn);
// Such a method handle must not be publically exposed directly
// otherwise it can be cracked, it must be transformed or rebound
// before exposure
MethodHandle mh = dmh.copyWith(mt, dmh.form);
assert mh.type().erase() == mn.getMethodType().erase();
return mh;
}
*/
// END Android-removed: Not used in Android implementation.
// BEGIN Android-removed: No VarForm in Android implementation.
/*non-public*/
/*
final void updateVarForm(VarForm newVForm) {
if (vform == newVForm) return;
UNSAFE.putObject(this, VFORM_OFFSET, newVForm);
UNSAFE.fullFence();
}
static final BiFunction