为什么System.gc（）在此代码中仅回收一个对象？

Question

In the code below, only one object cleared from heap memory at runtime (by calling System.gc() ). Why is only one object recycled?

 class A{
    A a;
    public A(A a){
      this.a=a;
    }
    public static void main(String args[]){
      A a1=null;
      A a2=new A(new A(null));
      A a3=new A(a2);
      a1=a3;
      a1.a=new A(null);
      a2.a=null;  //Line12
      System.gc();
    }
  }

Answer 1

I think it's horrid to try and pin exact GC-collection times in Java, but anyway ..

.. the Java garbage collection works on object reachability . If an object is strongly reachable - that is, if it can be accessed by any path from a reachability or known root, which includes local variables - then the object cannot be reclaimed ¹ .

Consider this breakdown, where W, X, Y, Z represent different instances of A. The syntax I use to show any particular A is instance {a-> instance} where a refers to the member variable. Remember each new creates a different instance, and that assignment of object values does not create new objects (as such the same Y object - now shared by a1 and a3 - is modified during a1.a=new A(null) assignment).

  A a1=null;                // a1 = null
  A a2=new A(new A(null));  // a2 = W {a-> X}
  A a3=new A(a2);           // a3 = Y {a-> W}    
  a1=a3;                    // a1 = a3 = Y {a-> W}
  a1.a=new A(null);         // a1 = a3 = Y {a-> Z}
  a2.a=null;                // a2 = W {a-> null}
  System.gc();

  // Then:
  // a1 = a3 = Y {a-> Z}    (Expanding: Y {a-> Z {a-> null}})
  // a2 = W {a-> null}

So at the end the variables a1 and a3 - which are reachability roots - are "referencing" Y {a->Z} and a2 is "referencing" W {a->null} . This means that W, Y and Z are all still strongly reachable (Z is strongly reachable through Y) and not considered eligible for reclamation in Java-land ² .

Only X is no longer reachable at the System.gc() line. However, this does not mean that X will be garbage collected, even with an explicit GC call - it only means that X is eligible to be reclaimed at some point in the future.

Of course, as soon as the function ends, all the local variables are no longer reachability roots and none of the A objects are strongly reachable making them all eligible :)

---

¹ Using object reachability to discuss a GC still works even when not using a traditional Mark & Sweep based approach (which is commonly found in JVMs) as the same rules apply to any correctly functioning GC system: if there is a chance an object can be accessed, it cannot be reclaimed. And conversely: if an object cannot be accessed, then it should be reclaimed.

² The rules to determine reachability roots differ by language/runtime. For instance, there are subtle differences with C#/CLRs handling in certain edge cases.

Answer 2

As others have pointed out, an object can be collected when it is accessible neither directly as the value of a variable nor indirectly because another accessible object has a reference to it. Let's go through the lines of code a few at a time and look at what the object reference graph looks like over time.

  A a1=null;               // 1
  A a2=new A(new A(null)); // 2
  A a3=new A(a2);          // 3
  a1=a3;                   // 4

Line 1 doesn't do much, and we could even eliminate it and change line 4 to A a1 = a3 without any different results. Line 2 sets a2 's value to a reference to a new instance of A , call it α, whose a field is a reference to a second new instance of A , call it β. Line 3 creates a new instance of A , call it γ, whose a field is a reference to α. Thus, all of α, β, and γ, are referenced. Line 4 makes a1 's value a reference to γ. Note that:

• α is directly accessible as a2 , and indirectly accesssible as long as γ is accessible;
• β is indirectly accessible through α, as long as α is accessible; and
• γ is directly accessible as a1 and a3 .

Next,

  a1.a=new A(null);        // 5

a1.a = new A(null) updates γ's a field to be a new instance of A , call it δ. Now:

• α is directly accessible as a2 , and not indirectly accessible through anything else;
• β is indirectly accessible only through γ;
• γ is directly accessible as a1 and a3 ; and
• δ is indirectly accessible only through α.

Finally,

  a2.a=null;               // 6

Now the last remaining reference to β is removed. There are still references to α, γ, and δ.

• α is directly accessible as a2 ;
• β is not accessible directly or indirectly at all;
• γ is directly accessible as a1 and a3 ; and
• δ is indirectly accessible only through γ.

Because β is not accessible at all, it is a candidate for garbage collection. The javadoc for System.gc() says:

Runs the garbage collector. Calling this method suggests that the Java virtual machine expend effort toward recycling unused objects in order to make the memory they currently occupy available for quick reuse. When control returns from the method call, the virtual machine has made its best effort to recycle all discarded objects.

Thus, when we get to

  System.gc(); // 7

the system may , but is not required to, collect β. It's probably safe to assume that β would be collected by a “best effort to recycle all discarded objects,” but it's not a guarantee.

Answer 3

Check the comments below:

public static void main(String args[]){
  A a1=null;
  A a2=new A(new A(null));  //a2.a = new A(null); //line 3
  A a3=new A(a2);           //a3.a = a2
  a1=a3;                    //a1 = a3
  a1.a=new A(null);         //a1.a = a3.a = null; a2 is still referenced
  a2.a=null;  //Line12      //a2.a = null => object at line 3 is cleared after gc
                            //because it is not referenced anymore by any variable.
  System.gc();
}