VolatileCallSite
open class VolatileCallSite : CallSite
| kotlin.Any | ||
| ↳ | java.lang.invoke.CallSite | |
| ↳ | java.lang.invoke.VolatileCallSite | |
A VolatileCallSite is a CallSite whose target acts like a volatile variable. An invokedynamic instruction linked to a VolatileCallSite sees updates to its call site target immediately, even if the update occurs in another thread. There may be a performance penalty for such tight coupling between threads.
In other respects, a VolatileCallSite is interchangeable with MutableCallSite.
Summary
| Public constructors | |
|---|---|
VolatileCallSite(target: MethodHandle!)Creates a call site with a volatile binding to its target. |
|
VolatileCallSite(type: MethodType!)Creates a call site with a volatile binding to its target. |
|
| Public methods | |
|---|---|
| MethodHandle! |
Produces a method handle equivalent to an invokedynamic instruction which has been linked to this call site. |
| MethodHandle! |
Returns the target method of the call site, which behaves like a |
| open Unit |
setTarget(newTarget: MethodHandle!)Updates the target method of this call site, as a volatile variable. |
| Inherited functions | |
|---|---|
Public constructors
VolatileCallSite
VolatileCallSite(target: MethodHandle!)
Creates a call site with a volatile binding to its target. The target is set to the given value.
| Parameters | |
|---|---|
target |
MethodHandle!: the method handle that will be the initial target of the call site |
| Exceptions | |
|---|---|
java.lang.NullPointerException |
if the proposed target is null |
VolatileCallSite
VolatileCallSite(type: MethodType!)
Creates a call site with a volatile binding to its target. The initial target is set to a method handle of the given type which will throw an IllegalStateException if called.
| Parameters | |
|---|---|
type |
MethodType!: the method type that this call site will have |
| Exceptions | |
|---|---|
java.lang.NullPointerException |
if the proposed type is null |
Public methods
dynamicInvoker
fun dynamicInvoker(): MethodHandle!
Produces a method handle equivalent to an invokedynamic instruction which has been linked to this call site.
This method is equivalent to the following code:
<code>MethodHandle getTarget, invoker, result; getTarget = MethodHandles.publicLookup().bind(this, "getTarget", MethodType.methodType(MethodHandle.class)); invoker = MethodHandles.exactInvoker(this.type()); result = MethodHandles.foldArguments(invoker, getTarget) </code>
| Return | |
|---|---|
MethodHandle! |
a method handle which always invokes this call site's current target |
getTarget
fun getTarget(): MethodHandle!
Returns the target method of the call site, which behaves like a volatile field of the VolatileCallSite.
The interactions of getTarget with memory are the same as of a read from a volatile field.
In particular, the current thread is required to issue a fresh read of the target from memory, and must not fail to see a recent update to the target by another thread.
| Return | |
|---|---|
MethodHandle! |
the linkage state of this call site, a method handle which can change over time |
See Also
setTarget
open fun setTarget(newTarget: MethodHandle!): Unit
Updates the target method of this call site, as a volatile variable. The type of the new target must agree with the type of the old target.
The interactions with memory are the same as of a write to a volatile field. In particular, any threads is guaranteed to see the updated target the next time it calls getTarget.
| Parameters | |
|---|---|
newTarget |
MethodHandle!: the new target |
| Exceptions | |
|---|---|
java.lang.NullPointerException |
if the proposed new target is null |
java.lang.invoke.WrongMethodTypeException |
if the proposed new target has a method type that differs from the previous target |
See Also