Do anonymous classes *always* maintain a reference to their enclosing instance?

by

As of JDK 18, no. JDK 18 omits enclosing instance fields from inner classes that don’t use it.

However, prior to JDK 18, yes, instances of anonymous inner classes hold on to a reference to their enclosing instances even if these references are never actually used. For example, this code:

public class Outer {
  public Runnable getRunnable() {
    return new Runnable() {
      public void run() {
        System.out.println("hello");
      }
    };
  }
}

…when compiled with javac, generates two class files: Outer.class and
Outer$1.class. Disassembling the latter, the anonymous inner class,
with javap -c yields:

Compiled from "Outer.java"
class Outer$1 extends java.lang.Object implements java.lang.Runnable{
final Outer this$0;

Outer$1(Outer);
  Code:
   0:   aload_0
   1:   aload_1
   2:   putfield        #1; //Field this$0:LOuter;
   5:   aload_0
   6:   invokespecial   #2; //Method java/lang/Object."<init>":()V
   9:   return

public void run();
  Code:
   0:   getstatic       #3; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   ldc     #4; //String hello
   5:   invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8:   return

}

The putfield line shows that a reference to the enclosing instance is
being stored in the field this$0 (of type Outer) by the constructor
even though this field is never used again.

This is unfortunate if you’re attempting to create small potentially
long-lived objects with anonymous inner classes as they’ll hold onto the
(potentially large) enclosing instance. A workaround is to use an instance of a static class (or a top-level class) instead. This is unfortunately more verbose.

More Related Contents:

  1. How can I read a large text file line by line using Java?
  2. Why is it bad practice to call System.gc()?
  3. When is the finalize() method called in Java?
  4. How does Java Garbage Collection work with Circular References?
  5. Does GC release back memory to OS?
  6. Is there a destructor for Java?
  7. Does assigning objects to null in Java impact garbage collection?
  8. When will a string be garbage collected in java
  9. Can we create an instance of an interface in Java? [duplicate]
  10. Java 8 Lambda Expressions – what about multiple methods in nested class
  11. Garbage collector in java – set an object null
  12. In Java, when does an object become unreachable?
  13. Circular References in Java
  14. How can I avoid garbage collection delays in Java games? (Best Practices) [closed]
  15. What is the actual memory place for static variables?
  16. When Is The Object Eligible For Garbage Collection?
  17. Does G1GC release back memory to the OS even if Xms = Xmx?
  18. Size of Huge Objects directly allocated to Old Generation
  19. NotSerializableException on anonymous class
  20. Why does the JVM require warmup?
  21. Anonymous-Inner classes showing incorrect modifier
  22. Garbage collection on intern’d strings, String Pool, and perm-space
  23. How does Java Garbage collector handle self-reference?
  24. What is the Metadata GC Threshold and how do I tune it?
  25. How to make a long time Full GC in Java manually
  26. Java GC (Allocation Failure)
  27. How to reduce java concurrent mode failure and excessive gc
  28. Static references are cleared–does Android unload classes at runtime if unused?
  29. How to read a verbose:GC output?
  30. What GC parameters is a JVM running with?

Leave a Comment