CallSite (Java SE 26 & JDK 26)
Description: declaration: module: java.base, package: java.lang.invoke, class: CallSite
Keywords: java.lang.invoke.CallSite class

# Class CallSite

java.lang.Object
java.lang.invoke.CallSite

Direct Known Subclasses:
  `ConstantCallSite, MutableCallSite, VolatileCallSite`

public abstract sealed class CallSite extends Object permits ConstantCallSite, MutableCallSite, VolatileCallSite
A `CallSite` is a holder for a variable `MethodHandle`, which is called its `target`. An `invokedynamic` instruction linked to a `CallSite` delegates all calls to the site's current target. A `CallSite` may be associated with several `invokedynamic` instructions, or it may be "free floating", associated with none. In any case, it may be invoked through an associated method handle called its dynamic invoker.

`CallSite` is an abstract sealed class which does not allow direct subclassing by users. It has three immediate, concrete non-sealed subclasses that may be either instantiated or subclassed.

- If a mutable target is not required, an `invokedynamic` instruction may be permanently bound by means of a constant call site.
- If a mutable target is required which has volatile variable semantics, because updates to the target must be immediately and reliably witnessed by other threads, a volatile call site may be used.
- Otherwise, if a mutable target is required, a mutable call site may be used.

A non-constant call site may be relinked by changing its target. The new target must have the same type as the previous target. Thus, though a call site can be relinked to a series of successive targets, it cannot change its type.

Here is a sample use of call sites and bootstrap methods which links every dynamic call site to print its arguments:

>     static void test() throws Throwable {
>         // THE FOLLOWING LINE IS PSEUDOCODE FOR A JVM INSTRUCTION
>         InvokeDynamic[#bootstrapDynamic].baz("baz arg", 2, 3.14);
>     }
>     private static void printArgs(Object... args) {
>       System.out.println(java.util.Arrays.deepToString(args));
>     }
>     private static final MethodHandle printArgs;
>     static {
>       MethodHandles.Lookup lookup = MethodHandles.lookup();
>       Class thisClass = lookup.lookupClass();  // (who am I?)
>       printArgs = lookup.findStatic(thisClass,
>           "printArgs", MethodType.methodType(void.class, Object[].class));
>     }
>     private static CallSite bootstrapDynamic(MethodHandles.Lookup caller, String name, MethodType type) {
>       // ignore caller and name, but match the type:
>       return new ConstantCallSite(printArgs.asType(type));
>     }

Sealed Class Hierarchy Graph:
Since:
  1.7

- ## Method Summary

  Modifier and Type
  Method
  Description
  `abstract MethodHandle`
  `dynamicInvoker()`
  Produces a method handle equivalent to an invokedynamic instruction which has been linked to this call site.
  `abstract MethodHandle`
  `getTarget()`
  Returns the target method of the call site, according to the behavior defined by this call site's specific class.
  `abstract void`
  `setTarget(MethodHandle newTarget)`
  Updates the target method of this call site, according to the behavior defined by this call site's specific class.
  `MethodType`
  `type()`
  Returns the type of this call site's target.

  ### Methods declared in class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
  Modifier and Type
  Method
  Description
  `protected Object`
  `clone()`
  Creates and returns a copy of this object.
  `boolean`
  `equals(Object obj)`
  Indicates whether some other object is "equal to" this one.
  `protected void`
  `finalize()`
  Deprecated, for removal: This API element is subject to removal in a future version.
  Finalization is deprecated and subject to removal in a future release.
  `final Class<?>`
  `getClass()`
  Returns the runtime class of this `Object`.
  `int`
  `hashCode()`
  Returns a hash code value for this object.
  `final void`
  `notify()`
  Wakes up a single thread that is waiting on this object's monitor.
  `final void`
  `notifyAll()`
  Wakes up all threads that are waiting on this object's monitor.
  `String`
  `toString()`
  Returns a string representation of the object.
  `final void`
  `wait()`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
  `final void`
  `wait(long timeoutMillis)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
  `final void`
  `wait(long timeoutMillis, int nanos)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

- ## Method Details

  - ### type

    public MethodType type()
    Returns the type of this call site's target. Although targets may change, any call site's type is permanent, and can never change to an unequal type. The `setTarget` method enforces this invariant by refusing any new target that does not have the previous target's type.
    Returns:
      the type of the current target, which is also the type of any future target

  - ### getTarget

    public abstract MethodHandle getTarget()
    Returns the target method of the call site, according to the behavior defined by this call site's specific class. The immediate subclasses of `CallSite` document the class-specific behaviors of this method.
    Returns:
      the current linkage state of the call site, its target method handle
    See Also:
      - `ConstantCallSite`
      - `VolatileCallSite`
      - `setTarget(MethodHandle)`
      - `ConstantCallSite.getTarget()`
      - `MutableCallSite.getTarget()`
      - `VolatileCallSite.getTarget()`

  - ### setTarget

    public abstract void setTarget(MethodHandle newTarget)
    Updates the target method of this call site, according to the behavior defined by this call site's specific class. The immediate subclasses of `CallSite` document the class-specific behaviors of this method.

    The type of the new target must be equal to the type of the old target.

    Parameters:
      `newTarget` - the new target
    Throws:
      `NullPointerException` - if the proposed new target is null
      `WrongMethodTypeException` - if the proposed new target has a method type that differs from the previous target
    See Also:
      - `getTarget()`
      - `ConstantCallSite.setTarget(MethodHandle)`
      - `MutableCallSite.setTarget(MethodHandle)`
      - `VolatileCallSite.setTarget(MethodHandle)`

  - ### dynamicInvoker

    public abstract MethodHandle dynamicInvoker()
    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:

    >     MethodHandle getTarget, invoker, result;
    >     getTarget = MethodHandles.publicLookup().bind(this, "getTarget", MethodType.methodType(MethodHandle.class));
    >     invoker = MethodHandles.exactInvoker(this.type());
    >     result = MethodHandles.foldArguments(invoker, getTarget)

    Returns:
      a method handle which always invokes this call site's current target