Question about the GC in Java

Question

Given
Given:
3. class Beta { }
4. class Alpha {
5. static Beta b1;
6. Beta b2;
7. }
8. public class Tester {
9. public static void main(String[] args) {
10. Beta b1 = new Beta(); Beta b2 = new Beta();
11. Alpha a1 = new Alpha(); Alpha a2 = new Alpha();
12. a1.b1 = b1;
13. a1.b2 = b1;
14. a2.b2 = b2;
15. a1 = null; b1 = null; b2 = null;
16. // do stuff
17. }
18. }Why there is only 1 object will be eligible for GC. I need a clear explanation pls

Answer 1

newbie wrote:
jverd wrote:
newbie wrote:
Pinto wrote:
Since this looks like a homework assignment, how about you post what you think the answer is. Rather than just spoonfeeding you the answer which you will just hand in as your own work.It is not a homework assignment. It is practice test from SCJP. Nevertheless, since you're trying to learn, you'll learn better if you think it through as much as possible yourself, post what you think and why and solicit feedback on that, rather than just asking for the answer.
How many objects do you think are eligible, and why?Thanks for your cheer.First of all I rename the instance variable of object Alpha. now i have
Given:
3. class Beta { }
4. class Alpha {
5. static Beta x;
6. Beta y;
7. }
8. public class Tester {
9. public static void main(String[] args) {
10. Beta b1 = new Beta(); Beta b2 = new Beta();
11. Alpha a1 = new Alpha(); Alpha a2 = new Alpha();
12. a1.x = b1;
13. a1.y = b1;
14. a2.y= b2;
15. a1 = null; b1 = null; b2 = null;
16. // do stuff
17. }
18. I have a stack containing a1, a2, b1, b2 and heap is containing 2 objects of type Alpha, 2 objects of type Beta, x, y *(AM I RITE AT HERE)*Yes. Note that x and y are part of the two Alpha objects.
At line 12 and 13, the instance variable y and class variable x of class Alpha point to an object of class Beta b1.Close. The instance variable y of one of the Alpha objects (not of the Alpha class) and the class variable x of class Alpha point to a Beta object--the same Beta that's pointed to by b1.
At line 14,*instance variable y* points to an object of class Beta b2.Instance variable y of the other Alpha object points to the second Beta object--the same one that's pointed to by b2.
Note that there are two y variables (one for each Alpha object) and one x variable (one for the Alpha class overall). That's the difference between an instance (non-static member) variable and a class (static member) variable.
Finally, at line 15, a1, b1, b2 are set to null. Yup.
Therefore, i think there are 2 objects which are eligible for GC ( 1 object of type Alpha and 1 object of type Beta)Well, let's see.
a1 is null, so nothing is pointing to the first Alpha, so it's GC-able. Additionally, that first Alpha's y is no longer pointing to the first Beta, so you might think that makes that Beta unreachable. However, the class variable x (which is not specific to any Alpha instance) is still pointing to the first Beta. So far, one GC-able object.
b1 is null, so it no longer points to the first Beta, but Alpha.x still points to the first Beta. Still one GC-able object.
b2 is null, so it no longer points to the second Beta, but the second Alpha's y still does, so the second Beta is still reachable. Still one GC-able object.
Remember, there are two y variables--one for each Alpha instance--and one x variable--one for the Alpha class as a whole.
Part of what makes this example confusing is they followed a syntactically legal but bad practice approach of using a reference variable to refer to a static class member, rather than the class name.
a1.x // legal, but confusing
Alpha.x // preferred
a1.y // the only legal way
Alpha.y // error, won't compile -- how would the compiler know WHICH Alpha instance's y variable we mean?