CODEWITHSUNDEEP
javaclassobject
Gibbs
Gibbs

Reputation: 22974

Life time of local variable in Java

     public List<Map<String,class1>> methodName(String Parameter)
     {
          //create instance of List
          List<Map<Strig,class1>> list1 = new ArrayList<Map<String,class1>>();

          for(ArrayList arrayList : someGlobalList)
          {
              //create instance of class1
              //Initialize class1 with values in arrayList
              //Put this class1 as a value to tempMap which is created inside this loop
              //Put that tempMap into List
          }
       return list1;
     }

My doubt

I understand that we cannot guarantee garbage collection. But this question says that when we return a local reference that will not be garbage collected. In my case, class1 is a local Object. But I am returning list1. Is it safe to use those objects from the caller function as list1.get("key"). It will return the class1 Object. Can I safely use the class members?

Upvotes: 1

Views: 1379

Answers (5)

Tiago Luis
Tiago Luis

Reputation: 11

Yes, you'll be able to access all the objects contained in the list object (list1) you are returning (including objects of type class1) as long as its reference is assigned to a reference variable in the method that called methodName. This is because there is no such thing as a local object. Objects live in the heap (unlike local variables which live on the stack) and they will only be eligible for garbage collection if there are no more reachable references to it.

Upvotes: 1

RealSkeptic
RealSkeptic

Reputation: 34628

An object is only eligible for garbage collection after the last reference to it is no longer reachable from your code.

Let's count the references to your newly created object. Each class1 object is only referenced from the list at the moment, so let's look at the references to the list itself.

You have one reference called list1.

Then you return a value. This creates a second reference, which is placed in the stack and passed up to the caller.

List<...> result = theObj.methodName("foo");

During that process the first reference (list1) is no longer accessible, but the reference that was returned back is still accessible - it will be assigned to the variable result in this case. So you still have one valid and accessible reference to the list. Therefore, every reference inside the list is also valid and accessible.

So yes, it is completely safe to use.

There are languages other than Java, where you can allocate an object in stack space. That is, the object itself is allocated locally. Returning a reference to such an object is unsafe as the stack frame is popped. Take this example in C, that returns a pointer to the beginning of a local array:

char *bad_string(void)
{
    /* BAD BAD BAD */
    char buffer[] = "local string";
    return buffer;
}

But in Java, objects are always allocated in heap space (barring internal optimizations which are not visible to the programmer and are checked to be safe, as mentioned in the comments).

An object allocated by the new operator is never "popped", and always obeys the rules of garbage collection. Stack/local method space is only used for primitives and references, and you never get a reference to any of those, only to objects. Thus, if you have a reference to something, you can trust that its memory is safe.

Upvotes: 3

TheLostMind
TheLostMind

Reputation: 36304

In my case, class1 is a local Object. But I am returning list1

If a reference leaks from a method, then that object can be used (safely? is again another question which is dependent on the exact definition of safe). In your case since you are returning list1, all local fields referenced by list1 (recursively) can be accessed without NPE (or the fear of them being GCed) because your list has a strong reference to those instances.

If you are talking about thread safety, then it depends on how many threads have access to this leaked reference(s).

Upvotes: 0

lscoughlin
lscoughlin

Reputation: 2416

Yes. The moment list1 leaves the frame ( is returned by the function ), it and all of it's references stop being "local variables" and will not be candidates for garbage collection until there are no longer any references to "list1"

Upvotes: 0

Marcin Szawurski
Marcin Szawurski

Reputation: 1333

You need to have only one reference. Objects referenced by this first referenced object will be free from GC as well.. and so on up the tree.

Upvotes: -1

Related Questions