DynamicLinker (Java SE 11 & JDK 11 ) (original) (raw)

• java.lang.Object

• • jdk.dynalink.DynamicLinker

• ---

public final class DynamicLinker
extends Object
The linker for RelinkableCallSite objects. A dynamic linker is a main objects when using Dynalink, it coordinates linking of call sites with linkers of available language runtimes that are represented byGuardingDynamicLinker objects (you only need to deal with these if you are yourself implementing a language runtime with its own object model and/or type conversions). To use Dynalink, you have to create one or more dynamic linkers using a DynamicLinkerFactory. Subsequently, you need to invoke its link(RelinkableCallSite) method frominvokedynamic bootstrap methods to let it manage all the call sites they create. Usual usage would be to create at least one class per language runtime to contain one linker instance as:
class MyLanguageRuntime {
private static final GuardingDynamicLinker myLanguageLinker = new MyLanguageLinker();
private static final DynamicLinker dynamicLinker = createDynamicLinker();
private static DynamicLinker createDynamicLinker() {
final DynamicLinkerFactory factory = new DynamicLinkerFactory();
factory.setPrioritizedLinker(myLanguageLinker);
return factory.createLinker();
}
public static CallSite bootstrap(MethodHandles.Lookup lookup, String name, MethodType type) {
return dynamicLinker.link(
new SimpleRelinkableCallSite(
new CallSiteDescriptor(lookup, parseOperation(name), type)));
}
private static Operation parseOperation(String name) {
...
}
}

The above setup of one static linker instance is often too simple. You will often have your language runtime have a concept of some kind of "context class loader" and you will want to create one dynamic linker per such class loader, to ensure it incorporates linkers for all other language runtimes visible to that class loader (seeDynamicLinkerFactory.setClassLoader(ClassLoader)).
There are three components you need to provide in the above example:

• You are expected to provide a GuardingDynamicLinker for your own language. If your runtime doesn't have its own object model or type conversions, you don't need to implement a GuardingDynamicLinker; you would simply not invoke the setPrioritizedLinker method on the factory.

• The performance of the programs can depend on your choice of the class to represent call sites. The above example usedSimpleRelinkableCallSite, but you might want to useChainedCallSite instead. You'll need to experiment and decide what fits your runtime the best. You can further subclass either of these or implement your own.

• You also need to provide CallSiteDescriptors to your call sites. They are immutable objects that contain all the information about the call site: the class performing the lookups, the operation being invoked, and the method signature. You will have to supply your own scheme to encode and decode operations in the call site name or static parameters, that is why in the above example the parseOperation method is left unimplemented.

• • Method Summary

  All Methods Static Methods Instance Methods Concrete Methods

  Modifier and Type	Method	Description
  static StackTraceElement	getLinkedCallSiteLocation()	Returns a stack trace element describing the location of theinvokedynamic call site currently being linked on the current thread.
  LinkerServices	getLinkerServices()	Returns the object representing the linker services of this class that are normally exposed to individual language-specific linkers.
  <T extends RelinkableCallSite>T	link​(T callSite)	Links an invokedynamic call site.

     * ### Methods declared in class java.lang.[Object](../../../java.base/java/lang/Object.html "class in java.lang")  
     `[clone](../../../java.base/java/lang/Object.html#clone%28%29), [equals](../../../java.base/java/lang/Object.html#equals%28java.lang.Object%29), [finalize](../../../java.base/java/lang/Object.html#finalize%28%29), [getClass](../../../java.base/java/lang/Object.html#getClass%28%29), [hashCode](../../../java.base/java/lang/Object.html#hashCode%28%29), [notify](../../../java.base/java/lang/Object.html#notify%28%29), [notifyAll](../../../java.base/java/lang/Object.html#notifyAll%28%29), [toString](../../../java.base/java/lang/Object.html#toString%28%29), [wait](../../../java.base/java/lang/Object.html#wait%28%29), [wait](../../../java.base/java/lang/Object.html#wait%28long%29), [wait](../../../java.base/java/lang/Object.html#wait%28long,int%29)`

• • Method Detail

     * #### link  
     public <T extends [RelinkableCallSite](RelinkableCallSite.html "interface in jdk.dynalink")> T link​(T callSite)  
     Links an invokedynamic call site. It will install a method handle into the call site that invokes the relinking mechanism of this linker. Next time the call site is invoked, it will be linked for the actual arguments it was invoked with.  
     Type Parameters:  
     `T` \- the particular subclass of [RelinkableCallSite](RelinkableCallSite.html "interface in jdk.dynalink") for which to create a link.  
     Parameters:  
     `callSite` \- the call site to link.  
     Returns:  
     the callSite, for easy call chaining.  
     * #### getLinkerServices  
     public [LinkerServices](linker/LinkerServices.html "interface in jdk.dynalink.linker") getLinkerServices()  
     Returns the object representing the linker services of this class that are normally exposed to individual [language-specific linkers](linker/GuardingDynamicLinker.html "interface in jdk.dynalink.linker"). While as a user of this class you normally only care about the [link(RelinkableCallSite)](#link%28T%29) method, in certain circumstances you might want to use the lower level services directly; either to lookup specific method handles, to access the type converters, and so on.  
     Returns:  
     the object representing the linker services of this class.  
     * #### getLinkedCallSiteLocation  
     public static [StackTraceElement](../../../java.base/java/lang/StackTraceElement.html "class in java.lang") getLinkedCallSiteLocation()  
     Returns a stack trace element describing the location of the`invokedynamic` call site currently being linked on the current thread. The operation is potentially expensive as it needs to generate a stack trace to inspect it and is intended for use in diagnostics code. For "free-floating" call sites (not associated with an`invokedynamic` instruction), the result is not well-defined.  
     Returns:  
     a stack trace element describing the location of the call site currently being linked, or null if it is not invoked while a call site is being linked.

Report a bug or suggest an enhancement
For further API reference and developer documentation see the Java SE Documentation, which contains more detailed, developer-targeted descriptions with conceptual overviews, definitions of terms, workarounds, and working code examples.
Java is a trademark or registered trademark of Oracle and/or its affiliates in the US and other countries.
Copyright © 1993, 2025, Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
All rights reserved. Use is subject to license terms and the documentation redistribution policy.