On Wed, 18 Nov 2026 06:34:59 GMT, Markus Grönlund <[email protected]> wrote:
>> I don't quite follow the logic here. Isn't it the old proxy classes that you >> want to be able to reclaim now that they are being replaced by new ones due >> to the redefinition? > >> I don't quite follow the logic here. Isn't it the old proxy classes that you >> want to be able to reclaim now that they are being replaced by new ones due >> to the redefinition? > > Yes—the obsolete proxy classes are precisely what we want to reclaim. This > change enables that for subsequent generations. It cannot retroactively > remove `STRONG_LOADER_LINK` from classes that were already defined with it. > Those remain retained for the lifetime of their defining loader; for the > built-in loaders, effectively the lifetime of the JVM. > > The distinction is between that initial strongly linked generation and the > additional generations produced by repeated instrumentation: > > 1. JFR Method Tracing targets a specific method, instrumenting it through > class retransformation. > 2. Retransformation runs the rewriter over **all methods** of the replacement > class, including methods whose bytecodes were unchanged. Each `invokedynamic` > instruction receives a fresh, initially unresolved entry. > 3. When execution reaches those sites, resolution invokes their bootstrap > methods again. Newly generated lambda proxy classes are now defined without > `STRONG_LOADER_LINK`, because the caller satisfies the redefinition predicate. > 4. Stopping tracing retransforms the class again to remove the > instrumentation. This again replaces the methods and their linkage state. > Proxy classes from the preceding generation can now unload once they are > otherwise unreachable, because they were defined without the strong loader > link. > 5. Further instrumentation cycles follow the same pattern: subsequent > obsolete generations can be reclaimed. > > The initial strongly linked generation remains. This change prevents repeated > instrumentation from continually adding further generations that must remain > alive for the lifetime of the loader. Another mechanism allows this lifetime choice to retain unnecessary implementation classes without retransformation. When multiple threads concurrently attempt to resolve the same invokedynamic instruction, the bootstrap method may be invoked several times. The Java Virtual Machine (JVM) selects the result of one invocation, while disregarding the results of other invocations. [JVMS §5.4.3.6](https://docs.oracle.com/javase/specs/jvms/se25/html/jvms-5.html#jvms-5.4.3.6) If each of these competing invocations generates implementation classes with STRONG_LOADER_LINK, discarding their linkage results does not permit the classes to be unloaded. These classes remain associated with the defining loader, including those whose implementations were never selected for the call site. This means even the initial resolution process can leave redundant implementation classes for the lifetime of the loader. As additional core-library functionality adopts class-generating bootstraps, more sites become susceptible to this retention. The current change addresses subsequent generations following redefinition or retransformation, but does not modify the initial-resolution scenario. ------------- PR Review Comment: https://git.openjdk.org/jdk/pull/33921#discussion_r4610074252
