[ 
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)

Reply via email to