1

I declared a strong reference-

Data data = new Data();

To make it eligible for garbage collection I made instance null-

data = null;

Now when I made reference null the object is not reachable and is garbage collected when GC runs.

And for using WeakReference-

Data data = new Data();
WeakReference<Data> weakRef = new WeakReference<Data>(data);

When I make reference variable null it will be eligible for garbage collection.

data = null;

When we use StrongReference we made its reference null to get it GC. In case of WeakRefernce also we need to make reference to object null to make it GC. What is difference between two. In case of Strong reference if we just make reference to object null it will eligible for GC and will be collected when GC runs.

anujprashar
  • 6,263
  • 7
  • 52
  • 86
  • http://stackoverflow.com/questions/9809074/java-difference-between-strong-soft-weak-phantom-reference – Unihedron Jun 04 '14 at 11:15
  • @Anuj I have added my answer for this, hope it will be also useful to you just like other good answers already here. I have just covered few things which I felt needed little more atrention, as already much has been covered in existing answers. My answer : stackoverflow.com/a/42114698/504133 – nits.kk Feb 08 '17 at 15:21

3 Answers3

3

If you have tangled objects (i.e. objcts that are not reachable anymore), the garbage collector is allowed to collect them and wipe them out. Note the wording: It is allowed. That means the garbage collector can decide not to collect them. In fact, it is not guaranteed that an object will be garbaged collected at all.

The difference between objects managed by a SoftReference or a WeakReference and a removed strong reference is the garbage collection strategy:

  • Softly reachable objects will be collected if there is a need of memory.
  • Weakly reachable objects will be collected at the very first attempt.
  • Otherwise unreachable objects will be collected at the collector's strategy (which might be similar to softly reachable, and is also tunable with some JVM parameters at startup).

Still, these are assumptions about the most probable strategy, but a garbage collector might decide in another way.

Just a note: Weak and soft references do not make sense when being used in a local scope. They are most probably used in instance fields, and one must always take care of the fact that the referred-to object might already be collected.

Seelenvirtuose
  • 20,273
  • 6
  • 37
  • 66
  • Thanks for reply. It cleared my doubt. Why JVM normally does not collect unreachable objects in first attempt as they are no longer reachable and cannot be used. – anujprashar Jun 04 '14 at 11:20
  • 1
    Collecting objects is a resource consuming process. Why do it if there is no need for it? – Seelenvirtuose Jun 04 '14 at 11:27
1

The difference is that you can know if GC collected data by calling weakRef.get() and testing if it returned null or not.

Evgeniy Dorofeev
  • 133,369
  • 30
  • 199
  • 275
  • So if we make a Strong Reference null GC may not clear it and in case of WeakReference it will be definitely cleared in next cycle of GC. Why GC may not clear an object referenced by Strong Reference even after making its reference null and nothing is pointing to the object. – anujprashar Jun 04 '14 at 11:05
  • Well, I am confused, your question's header says SoftReference not StrongReference and my answer is about Weak vs SoftRefernce difference – Evgeniy Dorofeev Jun 04 '14 at 11:08
  • Sorry, my question was about Strong reference and weakreference. Title was wrong by mistake. Thanks for pointing out. I have changed title. – anujprashar Jun 04 '14 at 11:10
0

Though the post already has some good answers ,there is just a little left which I would like to add. In the question it has been asked for

"When we use StrongReference we made its reference null to get it GC. In case of WeakRefernce also we need to make reference to object null to make it GC. What is difference between two ?".

Suppose we have an Object which is referenced by 2 strong references , x and y. if we make x = null the object that was being referenced by x is not yet eligible for garbage collection as still we have y referencing the same. Reading y will still result in outputting the not null object.

Now suppose we have an Object having one strong reference, say x and one weakreference, y. Now if we make x = null we can be sure that the object will be eligible for garbage collection. WeakReference will not prevent this object from being garbage collected.

Invoking the get() method on the weak reference may return null as soon as the object is garbage collected. Hence it is advisable to always check the returned object before use.

(Important) Also we need to make that we do not hold the returned non null value in any long living hard reference (like instance fields). If we get a weak reference then if we need then we should use weak reference as instance field and to get the object in any method, a local variable may be used to hold the returned object, it should be checked if its not null, and if so then further processing can be done using the object.

Now just an additional point for SoftReferences, they prevent the object from being garbage collected untill there is an low memory (below a threshold).

nits.kk
  • 5,204
  • 4
  • 33
  • 55