What does it mean to be eligible for gc?

[Marlene Miller]

I am trying to understand what it means to be eligible for garbage collection. (This is almost a trick question.)

class Test {
   void m() {
      Object o1 = new Object();
      Object o2 = new Object();
      Object o3 = new Object();
      o1 = o2 = o3 = null;
      int x = 1; //line 1
   }
   void t() {
      m();
      int y = 1;  //line 2
      System.gc();
      int z = 1;  //line 3
   }
   public static void main(String[] args) {
      new Test().t();
   }
} 

How many objects are eligible for garbage collection
a. at line 1?
b. at line 2?
c. at line 3?

[Francis Siu]

hi Marlene
Let me try
Perdict only
Assume the new object action which creates only one object (concept in c++) (not heap and stack concept)
How many objects are eligible for garbage collection
a. at line 1?
2
Because the three object are point to same object and the other two will be collected.
b. at line 2?
1
After finish the method m(),one object is collected
c. at line 3?
0
I hope that I can predict correctly.

[Bert Bates]

Marlene -
Ok I'll bite again, this seems to be straightforward, not tricky...
What do you think the answer is and why..
(btw I disagree with siu's answer)
-Bert

[Marlene Miller]

I think at lines 1, 2 and 3, the number of objects eligible for garbage collection could be 0, 1, 2 or 3.
The garbage collection thread could preempt the main thread and run prior to the execution of lines 1 and 2. The garbage collector could choose to reclaim none, some or all of the unreachable objects.
If the garbage collector reclaims an object, that object is no longer eligible for garbage collection.
Does that make sense to you? What do you think?

[peter greaves]

my amateurish explanation:
three objects get created in a method, and at line one the three references are set to null. so i'd say that the objects to which they refered are eligible. there are no external references to these local-method-scoped objects. they are not referenced by an external collection, and references to them are not returned by the method. i can't see anything that would keep then ineligible. but these are just the guesses of a humble ranch hand!...

[Bert Bates]

Marlene - Peter is basically right, check out this link and then see what you think...
https://coderanch.com/t/240324/java-programmer-SCJP/certification/One-more-time
Let me know !
-Bert
[ April 30, 2003: Message edited by: Bert Bates ]

[David Willis]

1. class Test {
2.     void m() {
3.         Object o1 = new Object();
4.         Object o2 = new Object();
5.         Object o3 = new Object();
6.         o1 = o2 = o3 = null;
7.         int x = 1; //line 1
8.     }
9.     void t() {
10.        m();
11.        int y = 1;  //line 2
12.        System.gc();
13.        int z = 1;  //line 3
14.    }
15.    public static void main(String[] a) {
16.        new Test().t();
17.    }
18. }

I'll take a stab at this, and I'm going to use my line numbering:
If GC was invoked by the JVM after execution of line 7 (Marlene's line 1), 3 objects are eligible for G.C. This is because the assignment operators on line 6 are evaluated from right to left (ie. o1 = o2 = o3 = null; is equivalent to o1 = (o2 = (o3 = null)); ) Therefore the objects that were previously referred to by o1, o2, and o3 are no longer referred to by a reference in a live thread, and therefore eligible for G.C.
If GC was invoked by the JVM no earlier than after execution of line 11, 3 objects are still eligilbe for G.C. This is because the int on line 7 is a method local primitive variable, and therefore created on the stack, not on the heap. The three Objects created in m() are eligible for GC by my explaination above, but even if line 6 was not present, they would be eligible since the reference variables o1, o2, and o3 are also method local, meaning they are also created on the stack, and removed once execution is returned to t() from m(). That would mean that the Objects are no longer referenced by any variables in a live thread, and eligible for GC.
If GC was invoked by the JVM no earlier than after execution of line 13, the same 3 objects are eligible for GC. Because System.gc() is only a suggestion, there is no guarantee that GC will be invoked by the time execution of line 13 occurs.
In summary, the three Object()s created in m() are eligible for GC anytime after line 6 is executed.
[ April 30, 2003: Message edited by: David Willis ]

[Marlene Miller]

1. Object o1 = new Object();
2. o1 = null;
3. int i = 1;
The main thread executes lines 1 and 2.
The garbage collector preempts the main thread.
The garbage collector reclaims the object.
The main thread resumes execution at line 3.
At line 3, the object is not eligible for garbage collection, because it has already been reclaimed. There is no object.

[Dorothy Finkel-Laverty]

Marlene - if you're talking about the certification test, then the question about "being eligible for gc" would only be asked at one point - so I would say 3 objects also. You don't really know WHEN gc will run, so once an object is made eligible for gc, you continue to say that it is "eligible" for gc - you never assume it has been collected.
David - I agree with your analysis.
Now, for extra credit, can you explain why you didn't even consider x, y, or z for garbage collection?

[Roger Chung-Wee]

Marlene, whilst I applaud your efforts to get an in-depth understanding of many areas of Java, I think that a "HIGHLY DETAILED NOT NEEDED FOR EXAM" warning is needed as most people may become confused or alarmed. For the exam, they will need to know a few key facts, eg.
1. gc normally runs in a low priority daemon thread.
2. gc cannot be forced by the programmer.
3. Only gc can destroy objects.
4. gc will call finalizer once before destroying objects.
5. Objects are eligible for gc if not reachable from any live thread.
On this basis, and for the exam, there would be three objects being eligible for gc at line 1.
[ April 30, 2003: Message edited by: Roger Chung-Wee ]

[David Willis]

Marlene, that's why I try to state in my analysis, "If GC is invoked no earlier than...". It's pointless to try to determine how many objects are eligible for GC if you can't specify when GC preempts the normal execution of a program.
Dorothy, the reason x, y and z are not eligible for GC is, because they are method local variables, they are allocated on the stack. Since x, y, and z are primitives, the bit patterns are stored in the locations allocated on the stack, rather than a reference to a location in the heap for an object. They are eliminated as soon as the methods they are instanatiated are popped of the stack.

[Barry Gaunt]

I agree with Roger, Marlene. Just think about it, with your answer you just dumped another 2 points down the chute. Think simple, the answer for SCJP2 is 3 at line 1.

[Marlene Miller]

Are you eligible to vote? Yes. Why? Because you are a citizen and you have registered. Now that your registration has expired, are you eligible to vote? No.
The garbage collector thread and the main thread are asynchronous.
(post script: I should have said - Now that you have expired...)
[ April 30, 2003: Message edited by: Marlene Miller ]

[David Willis]

Perhaps another way to study how GC works is rather than trying to determine how many objects are eligible for GC at a particular line without knowing whether GC was invoked prior to that line, ask the question of how many objects will have been cumulatively collected by the GC thread at a particular line of a program. This forces a person to examine when objects become available to be GC'ed without having to worry about how many times GC was invoked prior to the current line. I don't think the exam has questions phrased like this, though.

[Marlene Miller]

Thank you Sui, Bert, Peter, David, Dorothy, Roger and Barry.

[Bert Bates]

On the real exam you will often be asked
'At line x how many objects are eligible for GC'

[Jose Botella]

For considering how many objects are eligible for g.c.ion you do not have to worry about if the g.c.or has already run. It is necesary only to consider if the objects are reachable from a live thread. It is likely that the term eligible for g.c.ion was chosen to imply the dismisal of the ocurrances of g. collections at the point of the program being considered.

[Marlene Miller]

Thank you Bert and Jose. We are to assume the garbage collector does not run (even though this question is testing knowledge of garbage collection).
Now, suppose I had a fancy IDE that showed me the reachable objects and the unreachable objects as I stepped through my program.
Would anyone be willing to confirm that at lines 1, 2 and 3 in my example program, it is possible that I would see 0, 1, 2 or 3 unreachable objects of class Object? (not counting other objects created by the VM)

[Bert Bates]

Marlene -
If your fancy IDE ran it would say that as of line 1 there were three unreachable objects of class Object. No new objects are created subsequent to line 1 so your IDE wouldn't have anything new to say when it reached lines 2 or 3.
Did that other thread help?

[Marlene Miller]

Did that other thread help?

Bert, thank you for the link. I think I understand the concept of root references.
However, that discussion does not address the issue that concerned me, namely the effect of the garbage collector thread when counting eligible objects.
Some people think the number of eligible objects at line 1 is 3. But I think if the garbage collector thread preempts the main thread before line 1 is executed, some of those unreachable objects might be reclaimed. If they no longer exist, they cannot be eligible.
I guess I have to accept for now that some people do not want to think about the effect of the garbage collector thread.
[ May 01, 2003: Message edited by: Marlene Miller ]

[David Willis]

Taking into account your desire to not know whether or not GC has already preempted the main thread by the time it reaches lines 1, 2 or 3, then the answer to your questions are:
The amount of objects available for garbage collection is [0,3] at lines 1, 2, or 3.
But there is absolutely no way for you to know the precise number of objects, and it really isn't important, both from the perspective of taking the exam or from the practical perspective actually using Java to solve problems programatically. The whole point of these questions is to determine whether an exam taker understands when objects first become eligible for garbage collection. The answer to that question is: 3 objects become eligible after the execution of the line preceding line 1 ( o1 = o2 = o3 = null ) . They will be collected the next time GC preempts the main thread anytime after the reference variables are assigned null.

[Marlene Miller]

Thank you David.
It would have been much better if I had never asked my question. It is a very silly question. I will try to keep my questions appropriate to the purpose.
But if you should ever work through the 15 questions on garbage collection in Dan Chisholm�s Study Guide and try to understand what might or might not happen after System.gc is called so that you can predict whether and when Arnold will be back, then you might see why this happened.