Where does return value go in java if no variable assigned to accept it?

Question

Let\'s say a method returns some value, but when I call it, I don\'t assign any variable to accept this RV. Then where does it go? Will GC collect it? Would it be a problem

Answer 1

Will GC collect it?

Yes. Since there would be no live reference to the Object returned it would be eligible for GC.

Would it be a problem if I use this kind of method tons of times in my code?

It should not. All the returned Objects will be GCed.

Answer 2

Assuming the value isn't referenced anywhere else, it will be garbage collected

Answer 3

There's nothing that special about a return value over a local variable, consider:

public Object example {
  Object a = new Object();
  return new Object();
}

Then if I briefly explain how return values work:

When a method starts a new "stack-frame" is pushed on to the stack. It is an area of memory that includes parameter and local variable storage including the return value. It also knows where to return to.

When the method executes, new objects are created on the heap and only pointers to them exist in the stack.

After the code for the method has been run the value of a non-void return method is passed back to the calling method and stored in it's stack frame.

If a non-void return method's value isn't required by the caller, then it will share the same fate as any other local variable in that stack frame. And that is it's value is no longer used. If that value was an object, then garbage collection is already aware of it and is now able to ascertain that it is not referenced and can be collected.

Answer 4

Then where does it go?

It doesn't go anywhere. The value / reference is simply discarded. It is as if you assigned it to a local variable that immediately goes out of scope.

Will GC collect it?

It will be garbage collected when the garbage collector detects that it is unreachable. In your example, the method doesn't put the object reference anywhere else, so it will be unreachable immediately.

Note that even if the object is immediately unreachable, it may take some time for the GC to notice this and collect it. (But that's not a bad thing. It is more efficient that way.)

Would it be a problem if I use this kind of method tons of times in my code?

Not necessarily. The example code is not doing anything useful, and hence the overheads of allocating the object and then garbage collected are simply a waste of resources. But if it was doing something useful, the overheads are not likely to be a problem. (In ideal conditions, allocating and garbage collecting an object is cheap in Java.)

Unnecessary allocation can be a problem in some cases though:

• If you are running with a heap that is too small for the application's working set of objects, the overheads can ramp up.

• HotSpot's default "throughput" GC will "stop the world" while the GC is running, so excessive allocations will increase the number o f GC pauses that you experience. (This may or may not matter ... depending on the application.) You can mitigate this by using CMS or G1 as your collector, but that introduces overheads in other areas.