这会导致内存泄漏吗？

Question

I have recently read some SO posts/answers that suggest using anonymous class could cause memory leak. If I understood correctly, if an anonymous class' object reference leaks outside of the enclosing class, that could cause that anonymous class instance to be garbage non-collectible.

Just to make sure I understood correctly, am I right to say the below sample code would not cause memory leak?

public class EnclosingClass {
    private AnonymousClassBase anonymous;

    public void startDoingSomething() {
        this.anonymous = new AnonymousClassBase() {
            @Override public void anonymouslyDoSomething() {
                EnclosingClass.this.doSomething("Did something anonymously!");
            }
        };
        this.anonymous.anonymouslyDoSomething();
    }

    private void doSomething(final String something) {
        System.out.println(something);
    }
}

public abstract class AnonymousClassBase {
    public abstract void anonymouslyDoSomething();
}

public class MainClass {
    private final EnclosingClass enclosing = new EnclosingClass();

    // Some kind of button click event handler
    public void onButtonClicked() {
        this.enclosing.startDoingSomething();
    }
}

The private field anonymous can only store one instance of AnonymousClassBase , so calling startDoingSomething() the second time will cause the enclosing class to lose the reference of the first instance. At this point, is that first instance eligible for garbage collection?

Answer 1

Just to give an update what I found so others can hopefully benefit from it. I have further modified the codes to further illustrate the point:

public class EnclosingClass {
    private AnonymousClassBase anonymous;
    private Object enclosingClassField = new Object();

    public void startDoingSomething() {
        this.anonymous = new AnonymousClassBase() {
            // Takes some significant load on memory for each anonymous object
            private double[] memoryLoad = new double[9999999];

            // Just taking reference of something belonging to enclosing class
            private Object test = EnclosingClass.this.enclosingClassField;

            @Override public void anonymouslyDoSomething() {
                EnclosingClass.this.doSomething("Did something anonymously!");
            }
        };

        this.anonymous.anonymouslyDoSomething();
    }

    private void doSomething(final String something) {
        System.out.println(something);
    }
}

public abstract class AnonymousClassBase {
    public abstract void anonymouslyDoSomething();
}

public class MainClass {
    private final EnclosingClass enclosing = new EnclosingClass();

    // Some kind of button click event handler
    public void onButtonClicked() {
        this.enclosing.startDoingSomething();
    }
}

The main difference is that the anonymous object will each take a memory load of almost 76.3MB for each anonymous object. The JVM slowly increased to approximately 2.9GB and dropped to about 300MB - which indicated that a garbage collection did occur to remove those anonymous class objects.

Therefore my conclusion is that anonymous class objects can hold reference of anything belonging to their enclosing class object. When the anonymous class object is holding a reference of something that even its enclosing class object no longer hold, then it will also lose reference of that. In certain sense, the anonymous class object is holding a weak reference of its enclosing class object, and any object reference belonging to the enclosing class object is derived from enclosing class (eg that enclosingClassField object in the example).