Doubt about CH3 Q11: how many objects eligible for garbage collection? (K&B7)

[Bill barrett]

In Chapter 3, Q-11, on P218 I see the following:

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. }

When line 16 is reached, how many objects will be eligible for garbage collection?
A. 0
B. 1
C. 2
D. 3
E. 4
F. 5

The answer says B. The book says the following:
"we can now say with stunning clarity and resolve that an object is eligible
for garbage collection when no live thread can access it"

Is this question worded wrong?

[Roel De Nijs]

Hi Bill,

First of all, a warm welcome to CodeRanch!

I moved your post out of the errata thread, so we can discuss this question more easily. If it turns out to be an errata, I'll post a link to this thread in the errata thread (and update the errata overview accordingly). Hope that's ok with you!

Can you explain a little bit more why you think this question is worded wrong based on the statement (on page 201) "we can now say with stunning clarity and resolve that an object is eligible for garbage collection when no live thread can access it"? Because I don't see what's possibly wrong with this question. The code creates 4 objects and you have to decide how many will be eligible for GC. If no reference variable is referring to an object anymore, no live thread can access it, and this the object is eligible for GC.

Best wishes for 2015!
Kind regards,
Roel

[Bill barrett]

Thank Roel and Happy New Year.

My disconnect with the ch3 q11 is that three of the four objects created were set to null. Isn't it the null objects that are eligible for GC?
At line 16, there is still one object that can be reached, therefore it is not eligible for GC.

Thanks
Bill

[Sergej Smoljanov]

http://www.javaranch.com/campfire/StoryPassBy.jsp
maybe this will help

[Roel De Nijs]

Bill barrett wrote:My disconnect with the ch3 q11 is that three of the four objects created were set to null. Isn't it the null objects that are eligible for GC?
At line 16, there is still one object that can be reached, therefore it is not eligible for GC.

First of all, there is no such thing as a null object! A reference variable can be set to null, which means "not refering to any object".

Secondly, as said in my previous post: "If no reference variable is referring to an object anymore, no live thread can access it, and this the object is eligible for GC.". But that doesn't mean you can simply count how many reference variables are assigned to null to get your answer. If it were only that simple! Don't forget an object can be referenced by many reference variables. So if just 1 reference variable is set to null, the object can still be referenced by the other non-null reference variables. So the best way to solve this kind of questions (on the mock and actual exams) is to make a little drawing: reference variables on the left, objects on the right and you draw arrows between reference variables and objects based on the code snippet. If a reference variable is set to null, you delete/remove all outgoing arrows from that reference variable. All objects which don't have an arrow anymore are unreachable and thus eligible for GC.

I made a little drawing myself of this question to illustrate and give you a better idea of this jibber jabber

So have a look at the accompanying drawing. With each arrow or cross I added the according statement from the code snippet. So if you look closely you'll see that just 1 object doesn't have any arrows anymore (the Alpha object which was initially referred by a1) and thus is eligible for GC, all other objects are still reachable through reference variables a2, a2.b2 and Alpha.b1 (therefore not eligible for GC).

Hope it helps!
Kind regards,
Roel

[Sergej Smoljanov]

Roel De Nijs you are great
also paint way creation:
static Alpha.b1 mean reference that from code is Alpha.b1 (reference to static variable)

[Roel De Nijs]

Sergej Smoljanov wrote:Roel De Nijs you are great

I know

Sergej Smoljanov wrote:also paint way creation:

As I don't have paint on the actual exam, I used blue and green ballpoint pens Although you were a lot slower than me I awarded you a cow for this great post!

[Wagner Fonseca]

Hi,

I am still confused.

And the Beta object referenced in a2.b2?

The reference variable b2 is null, but still reference variable a2.b2 still refer to b2, this means which still the object live on the heap?

I created code:

public class TesterKBCP3Q11 {

	public final static void main(String[] args) {
		Beta b1 = new Beta(); b1.name="I'm object beta 1"; 		
		Beta b2 = new Beta(); b2.name="I'm object beta 2";			
		
		Alpha a1 = new Alpha(); a1.id=111; 
		Alpha a2 = new Alpha(); a2.id=222;
		
		System.out.println("code b1: " + b1.hashCode());
		System.out.println("code b2: " + b2.hashCode());
		
		a1.b1 = b1;
		System.out.println("a1.b1 refer b1: "+a1.b1.name);
		a1.b2 = b1;
		System.out.println("a1.b2 refer b1: "+a1.b2.name);
		a2.b2 = b2;
		System.out.println("a2.b2 refer b2: "+a2.b2.name);
		
		a1 = null; b1 = null; b2 = null;
		
		System.out.println("old refer b2: " + a2.b2.name);
		System.out.println("code b2: " + a2.b2.hashCode());

                try {
			System.out.println("code b1: " + b2.hashCode());
		} catch(NullPointerException e) {
			System.out.println("This Object not exits");
		}

	}
}

class Beta { 
	String name;
}
class Alpha {
	int id;
	static Beta b1;
	Beta b2;
}

out print:
code b1: 31289430 code b2: 16399041 a1.b1 refer b1: I'm object beta 1 a1.b2 refer b1: I'm object beta 1 a2.b2 refer b2: I'm object beta 2 old refer b2: I'm object beta 2 code b2: 16399041 This Object not exits

thanks

[Joe Bishara]

Wagner Fonseca wrote:I am still confused.

I hope this diagram makes it a little clearer.

[Roel De Nijs]

Wagner Fonseca wrote:I am still confused.

And the Beta object referenced in a2.b2?

The reference variable b2 is null, but still reference variable a2.b2 still refer to b2, this means which still the object live on the heap?

Correct!

As mentioned in previous posts (and also visible in the drawings): just 1 object isn't reachable anymore through a reference variable (the Alpha object which was initially referred by a1) and thus is eligible for GC, all other objects are still reachable through reference variables a2, a2.b2 and Alpha.b1 (therefore not eligible for GC).

[Wagner Fonseca]

thank you all,

now no doubts.

Alpha.b1 is instance variable static and keeps the object alive in heap. Here was my doubts.

thanks

[Roel De Nijs]

Wagner Fonseca wrote:Alpha.b1 is instance variable static

Be careful! There's no such thing as an instance variable static. It's either a class variable (also known as static variable) or an instance variable. Alpha.b1 is clearly a class/static variable.

[Roel De Nijs]

Joe Bishara wrote:

Wagner Fonseca wrote:I am still confused.

I hope this diagram makes it a little clearer.

Have a cow for that!

[Joe Bishara]

Thanks for the cow and thanks for broadening my knowledge of garbage collection.

[Vidya Shivram]

Hello,
Above explanation were nice to understand garbage collection concept. I have changed the condition in the above code ( I mean assigned null to different variables ) and analysed the code as below.
Please let me know if I have got it right?

Also, Garbage Collector is not guaranteed to run always. So, Is there any way to find out how many objects are eligible for garbage collections through code?

[Pete Letkeman]

@Chivid Ram eligible for collection does not mean that collection will happen, as you stated above one can not be sure that garbage collection happens.

[Vidya Shivram]

The link was broken.Here is the Image