HashMap being garbage collected along with WeakHashMap?

Question

As of my understanding HashMap should not be garbage collected and WeakHashMap should be garbage collected but When I'm running this code both hashmap and weakhashmap are being garbage collected.

import java.util.HashMap;
import java.util.WeakHashMap;
public class WeakHashMapDemo {
    public static void main(String[] args) {
        HashMap<String,Temp> hashMap= new HashMap<>();
        hashMap.put("a", new Temp("hashmap"));
        WeakHashMap<String,Temp> weakHashMap= new WeakHashMap<>();
        weakHashMap.put("a", new Temp("identity hashmap"));
        hashMap= null;
        weakHashMap= null;
        System.gc();
        try {
            Thread.sleep(5000);
        }catch(InterruptedException interruptedException) {
            interruptedException.printStackTrace();
        }
        System.out.println(hashMap);
        System.out.println(weakHashMap);
    }
}
class Temp {
    String name;
    Temp(String name) {
        this.name= name;
    }
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println(name+":: Finalize Method Executed");
    }
    @Override
    public String toString() {
        return this.name;
    }
}

Output:

identity hashmap:: Finalize Method Executed
hashmap:: Finalize Method Executed
null
null

While using only HashMap, it is not being garbage collected by the GC.

import java.util.HashMap;
import java.util.WeakHashMap;
public class WeakHashMapDemo {
    public static void main(String[] args) {
        HashMap<String,Temp> hashMap= new HashMap<>();
        hashMap.put("a", new Temp("hashmap"));
        System.gc();
        try {
            Thread.sleep(5000);
        }catch(InterruptedException interruptedException) {
            interruptedException.printStackTrace();
        }
        System.out.println(hashMap);
    }
}
class Temp {
    String name;
    Temp(String name) {
        this.name= name;
    }
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println(name+":: Finalize Method Executed");
    }
    @Override
    public String toString() {
        return this.name;
    }
}

Output:

{a=hashmap}

Answer 1

First of all do not use finalize - it has been deprecated, there are better ways to clean after yourself and SO is full of such posts (ReferenceQueue and SoftReferences are among such).

Then don't use objects that are cached internally as keys in WeakHashMap (String is such).

Last point is that this has nothing to do with WeakHashMap, this is basic liveliness of Objects. In your first example you explicitly set the reference to null, thus they are cleared by GC, in your second one you don't, and keep a strong reference to it via System.out.println(hashMap);; thus it will not get collected.

Answer 2

I think you misunderstood how GC works.

In one sentence: Instances of classes are garbage collected when they are not referenced anymore. It has nothing to do with the type.

This is why is so important to pay attention to the scope of variables. If you keep a reference to an object that you don't need anymore, it won't be collected and you will waste resources.

Also, you are calling System.gc()... You can't programmatically call the GC. It will run according to its own rules. At best, you can "suggest" the JVM that you'd like the GC to run.

I'd advise you to take a look at: https://www.dynatrace.com/resources/ebooks/javabook/how-garbage-collection-works/

Answer 3

In your first example, you set the hashMap variable to null. There is then no reference to the HashMap object anymore, and it can be garbage collected just like any other type of object would. HashMap and WeakHashMap are no different in this regard.

The difference is that the keys in a WeakHashMap may be garbage collected when there are no outside references to them. In a normal HashMap, this won't happen because the map itself holds references to the keys.

Once keys have been collected, the WeakHashMap may clear the entire corresponding entry. this answer goes into more detail about it.

Answer 4

At line hashMap= null; you De-Referenced the object of HashMap. In any case after setting the null , on next cycle of Garbage collection it will collected by Garbage Collector.

In second case you are not settting the hashMap to null.

the difference between both of them :

WeakHashMap is an implementation of the Map interface. WeakHashMap is almost same as HashMap except in case of WeakHashMap, if object is specified as key doesn't contain any references- it is eligible for garbage collection even though it is associated with WeakHashMap. i.e Garbage Collector dominates over WeakHashMap.