CODEWITHSUNDEEP
javaoopmemoryarraylistmemory-management
AskingSeriousquestions
AskingSeriousquestions

Reputation: 9

How to not reference an Object when it is not used so it gets deleted by GarbageCollection

I have an array list that will constantly have different amounts of items in it.

It won't be deleted when it's empty.

Can this cause memory leaks?

I see people saying to make something eligible for garbage collection you have to de-reference it. What does this mean?

Upvotes: 0

Views: 678

Answers (3)

Stormcloud
Stormcloud

Reputation: 2297

Developers sometimes talk about "memory leaks" in Java. What they mean is that they have a lot of memory allocated that they no longer require, but in principle the application could reference if it wanted to. This is different from the "classical memory leak" which you would see in a language like 'C' where the application explicitly has to allocate an deallocate memory. As this question is about Java I won't concern myself with the "Classical Memory Leak", but just understand that the two are different

As @hdw3 correctly states, in Java an object is eligible for garbage collection if you have no reference to it. This is a specific case of a more general rule - an object is eligible for garbage collection if it can not be referenced in any way by your application. There is a subtle but important difference here...

Case 1 If you have a reference to object 'A' and that object has a reference to object 'B'. (This could be your ArrayList if contains a single item.) Neither object is eligible for garbage collection as the String can be referenced through the list.

As soon as you loose the referenced to your first object then neither object is accessible from your application, so both become eligible for garbage collection.

Case 2 Imagine you have a reference to object 'A' and that object has a reference to object 'B', AND object 'B' has a reference back to object 'A'. Objects 'A' and 'B' are both accessible so neither are not eligible for garbage collection.

As soon as you loose your reference to object 'A' then 'B' also becomes inaccessible. Both objects become eligible for garbage collection, even though they reference each other.

You can loose your reference to the object in a couple of different of ways.

  1. The usual way is to simply exit a method that has the only reference to the object.
  2. As @hdw3 points out reassign your reference so that it points to something
  3. Something called "SoftReferences" exist, but you only need to worry about them if you are implementing large caches.

What you'll find is that in Java the Garbage Collector almost always does the right thing for you and you don't need to bother about memory too much.

The Java "Memory Leak" I mentioned earlier occurs if you've got a large structure you application no longer requires, but in theory the application could reference objects in that structure. For example you've got a massive List of Strings, you've finished processing them but haven't existed the method yet. This is when you'd assign your reference to null, to make ALL objects in the structure eligible for garbage collection

Upvotes: 0

hdw3
hdw3

Reputation: 951

You can set reference to null to "de-reference" object. Like this for example:

Object o = new Object();
o = null;

In java when nothing points to the object (there is no reference to the object) then the object is "eligible" for garbage collector.

When it comes to memory leaks it really depends on your situation but it is possible to have some leaks due to not de-referencing.

Upvotes: 1

duffymo
duffymo

Reputation: 308763

An empty array is not a memory leak risk.

Memory leaks happen when a collection accepts unlimited references. It's hard to see how an empty list will be a problem.

An object that has a reference to an empty list will keep it in memory.

The garbage collector will mark an object as eligible for garbage collection when no other object refers to it. All references to that object have to be removed.

Upvotes: 1

Related Questions