[
https://issues.apache.org/jira/browse/GROOVY-8113?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18143980#comment-18143980
]
ASF GitHub Bot commented on GROOVY-8113:
----------------------------------------
blackdrag commented on PR #3109:
URL: https://github.com/apache/groovy/pull/3109#issuecomment-6834104147
The main concern I have with this approach is that it still infers that a
class cannot be loaded from the absence of a class resource and the absence of
an entry in a `GroovyClassLoader` cache. Neither establishes that a class
loader cannot provide the class.
`ClassLoader.loadClass` is not restricted to classes backed by resources. A
parent loader may already have a class defined, generate it on demand, or
otherwise make it available without exposing a `.class` resource. This is
particularly relevant here because Groovy supports custom class loaders and has
existing code paths that deliberately use `loadClass` to resolve classes that
exist only in memory.
There are two places where this assumption affects behavior:
* **`GroovyClassLoader`:** `throwIfParentWouldOnlyRecordAMiss`
short-circuits parent delegation for names containing `$` (except the special
`java.lang.$` case) when no resource or cached class is found. This can turn a
successful parent lookup into a `ClassNotFoundException`. The fact that the
name resembles an inner class does not establish that it is a generated name
that the parent cannot resolve.
* **`MetaClassRegistry`:** `customMetaClassVisible` similarly skips
`Class.forName` when no ancestor `GroovyClassLoader` cache entry or class
resource is found. This can prevent a custom MetaClass supplied by a
resource-less class loader from being discovered. The added test covers a
MetaClass defined directly in the registry loader, but does not exercise this
case through a parent loader.
I think the optimization should be based on **positive knowledge about the
name being probed**, rather than an inference that the name cannot be resolved.
In particular, we should avoid delegation only for a generated companion
name that it knows belongs to a script or template and that cannot be supplied
by the relevant parent lookup path. All other names should continue through the
existing class-loading mechanism. The same principle should apply to the custom
MetaClass lookup: identify the specific generated-script companion probes that
are safe to skip, rather than treating a missing resource as proof that a
custom MetaClass is unavailable.
This would also avoid having the optimization depend on increasingly
elaborate approximations of what arbitrary class loaders can load. The class
loader's own resolution mechanism should remain authoritative unless Groovy has
specific knowledge that a particular generated lookup is unnecessary.
I would add regression tests for both cases:
- A parent class loader that can provide a class without exposing a `.class`
resource, where the requested name contains `$`.
- A custom MetaClass available through a parent class loader but without a
corresponding `.class` resource.
The existing tests demonstrate the retention problem and cover several
ordinary lookup cases, but they do not establish that these short-circuits
preserve the existing class-loader contract.
> Groovy script/template engine produce memory leak
> --------------------------------------------------
>
> Key: GROOVY-8113
> URL: https://issues.apache.org/jira/browse/GROOVY-8113
> Project: Groovy
> Issue Type: Bug
> Components: groovy-templates, GroovyScriptEngine
> Affects Versions: 2.4.8
> Environment: Groovy 2.4.8, Oracle Java JDK 8u121
> Reporter: Artyom Kravchenko
> Priority: Critical
> Attachments: merged_path.png, object_explorer.png
>
>
> There is a simple way to produce OutOfMemoryException if run infinite
> numbers of groovy scripts or evaluate groovy templates.
> Simple test to reproduce a memory leak(run groovy script and make template
> inside the script):
> set max heap size: -Xmx7m
> {code:java}
> import javax.script.*;
> import java.util.HashMap;
> import java.util.Map;
> public class OutOfMemoryTest {
> private static String TEMPLATE = "Dear ${fullName} please go away at
> ${time}";
> private static String SCRIPT = "def run(args) {\n" +
> "def bindings = ['fullName' : 'Ali Baba', 'time' : new Date()]\n"
> +
> "println
> args.templateEngine.createTemplate(args.template).make(bindings).toString()\n"
> +
> "}";
> public static void main(String... args) {
> //
> GroovySystem.getMetaClassRegistry().getMetaClassCreationHandler().setDisableCustomMetaClassLookup(true);
> while(true) {
> ScriptEngineManager engineManager = new ScriptEngineManager();
> ScriptEngine engine = engineManager.getEngineByName("groovy");
> try {
> engine.eval(SCRIPT);
> } catch (ScriptException e) {
> throw new RuntimeException(e);
> }
> groovy.text.SimpleTemplateEngine templateEngine = new
> groovy.text.SimpleTemplateEngine();
> Invocable inv = (Invocable) engine;
> Map<String, Object> params = new HashMap<>();
> params.put("template", TEMPLATE);
> params.put("templateEngine", templateEngine);
> Object[] runArgs = { params };
> try {
> inv.invokeFunction("run", runArgs);
> } catch (ScriptException | NoSuchMethodException e) {
> e.printStackTrace();
> }
> }
> }
> }
> {code}
> The main cause of issue is Java class loader. Two instances:
> sun.misc.Launcher.AppClassLoader and sun.misc.Launcher.ExtClassLoader
> (parent for first one), each of them has a strong reference:
> {code:java}
> ConcurrentHashMap<String, Object> parallelLockMap
> {code}
> It collects all loaded classes (and never releases their) for application
> including newly created script/template classes.
> The main reason of introduction of this reference described here:
> https://blogs.oracle.com/dholmes/entry/parallel_classloading_revisited_fully_concurrent
> For each iteration of my test I see that parallelLockMap grows with 6 new
> entries:
> {code:java}
> groovy.runtime.metaclass.Script94MetaClass
> Script94BeanInfo
> Script94Customizer
> groovy.runtime.metaclass.SimpleTemplateScript94MetaClass
> SimpleTemplateScript94BeanInfo
> SimpleTemplateScript94Customizer
> {code}
> See memory snapshots(attached): objects_explorer, merged_path.
> I have found a partial solution of the issue, if I add this code line to my
> test:
> {code:java}
>
> GroovySystem.getMetaClassRegistry().getMetaClassCreationHandler().setDisableCustomMetaClassLookup(true);
> {code}
> I see that classes like:
> {code:java}
> groovy.runtime.metaclass.Script94MetaClass
> groovy.runtime.metaclass.SimpleTemplateScript94MetaClass
> {code}
> goes away (groovy engine don't ask ClassLoader to find this classes on class
> path therefore such classes are not collected by ClassLoader) but classes
> like
> {code:java}
> Script94BeanInfo
> Script94Customizer
> SimpleTemplateScript94BeanInfo
> SimpleTemplateScript94Customizer
> {code}
> still has affect on memory.
> Dear developers, could you please point me any advice/workarounds for this
> issue. It will be fine to get rig this issue in future releases.
--
This message was sent by Atlassian Jira
(v10.3.26#10030026)