Garbage Collector doesn't immediately collect finished thread

Question

In short: I have a thread which is finished running, but not garbage collected.

In long: See following example code:

public void saveSomething() {
    Thread thread = new Thread(new Runnable() {

         @Override
         public void run() {
             // heavy memory access (~400 MB), finishes after ~10sec
         }
    });
    thread.start();
}

Okay, so this thread gets started and finished after some time. During this time a lot memory is used, which is okay. But my problem is:

After the thread finished, the memory is not set free

And I don't know how I can ensure that. Finished threads, which are not used anymore, should get garbage collected as far as I'm informed; but this doesn't seem to happen here :(

See this screenshot from jvisualVM:

1: I trigger the thread start by calling saveSomething()

2: Thread was finished long ago (I saw it by debugging), and I pressed "Perform GC" in jvisualvm

As you can see, after I force the GC, everything is working like I want. But this has to happen automatically. How can I do that, what am I doing wrong?

If you need more infos, please ask. Note: It seems that after a day (hopefully shorter) the memory is back to normal, maybe the GC is just "slow" or rather not very frequently timed?

Answer 1

Could it be that you are asking the wrong question? What I mean: is the fact that garbage collection is not happening "immediately" a problem for you?

I am pretty sure - when you start another such thread that needs a lot of memory, the GC will kick in all by itself.

If that "delay" is actually a problem for you, you might consider doing the "very deep dive" in order to understand how GC actually works for your version of the JVM; to then start using the many many command line options that exist to fine-tune GC behavior to your needs.

But if a "delay" in freeing up memory (to other Java objects) is not an issue; then don't start fixing it.

Answer 2

Garbage collection doesn't happen as soon as the thread is finished. Garbage collection will happen when it happens. The fact that when you force garbage collection via visualvm, the thread and its resources are collected correctly implies everything is ok. If you wait long enough or do more things which consume the heap then eventually your thread will be GCed.

EDIT The only caveat to this is that a running thread, even with no references, will not be garbage collected.

Answer 3

I agree with the previous answers. This program demonstrates the fact that the "problem" is not specific to thread creation. In general, gc is done when needed or when specifically requested.

public class Test {

  public static long memInUse(){
    Runtime r = Runtime.getRuntime();
    return r.totalMemory()-r.freeMemory();
  }

  public static void main(String[] args){
    System.out.println("Initial memory: "+memInUse());
    long[] bigArray = new long[1000000];
    System.out.println("Memory after array allocation: "+memInUse());
    long endTime = System.currentTimeMillis()+10000;
    while(System.currentTimeMillis() < endTime){
      System.out.println("While array exists: "+memInUse());
      try{
        Thread.sleep(1000);
      }catch(InterruptedException e){
        // Deliberately ignore the exception.
      }
    }
    bigArray = null;
    System.out.println("After null assignment: "+memInUse());
    endTime = System.currentTimeMillis()+10000;
    while(System.currentTimeMillis() < endTime){
      System.out.println("While array reference null: "+memInUse());
      try{
        Thread.sleep(1000);
      }catch(InterruptedException e){
        // Deliberately ignore the exception.
      }
    }
    System.gc();
    System.out.println("After gc: "+memInUse());
  }
}

Output:

Initial memory: 2684536
Memory after array allocation: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
While array exists: 10684552
After null assignment: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
While array reference null: 10684552
After gc: 1622584

Answer 4

It's entirely possible that the JVM simply doesn't need to do a GC after the thread finishes as it has enough free heap anyway.

It'll only do a GC when it NEEDS to free up memory.

Personally, I wouldn't worry about it. As long as you know the memory will be cleared when a GC does happen, then it's fine.

If you really want to force it though, you'll have to do an explicit System.GC -either after the thread has finished, or as the last line in the run() method (assuming there are no further references to the large data at that stage).

Answer 5

1. Free memory is wasted memory. If you have, say, 2 GB of free RAM, then you could as well have 2 GB less. Freeing up memory isn't beneficial by itself, it won't automagically speed things up.

2. Garbage collection is not free. Actually it can be quite CPU-intensive. The less often it happens, the better (from CPU load perspective).

With that in mind, you usually don't want garbage collector to kick in immediately when the thread is finished. If you don't need more RAM at the very moment, then there's no point to burn CPU cycles on GC. Most of the time you can trust JVM to run GC when it's needed.

---

^{Bonus: RAM that isn't used by programs can be used for cache by your OS. On Windows this part of RAM is shown as free, in Linux it appears as used, but actually it's somewhere in between. Cache is not necessary, but it can improve performance. OS will manage it automatically: when more free RAM is available, then more can be allocated for cache, and when you're short on memory, cache size is reduced. So sometimes having more free RAM can be good for performance, but most of the time you don't have to worry about it.}

Answer 6

Generally an object becomes eligible for garbage collection in Java on following cases:

1) All references of that object explicitly set to null e.g. object = null

2) Object is created inside a block and reference goes out scope once control exit that block.

3) Parent object set to null, if an object holds reference of another object and when you set container object's reference null, child or contained object automatically becomes eligible for garbage collection.

4) If an object has only live weak references via WeakHashMap it will be eligible for garbage collection.

There are methods like System.gc() and Runtime.gc() which is used to send request of Garbage collection to JVM but it’s not guaranteed that garbage collection will happen.

To answer your question. you need to force garbage collection.

System.gc ();
System.runFinalization ();

Other Example

public class GCTest {
    public static void main(String[] args) throws InterruptedException {
        A a = new A("white");
        a = null;

        Runtime.getRuntime().gc();
    }
}

class A {
    private String color;

    public A(String color) {
        this.color = color;
    }

    @Override
    public void finalize() {
        System.out.println(this.color + " cleaned");
    }
}

Warning it is a terrible practice to use the garbage collector because the use of it could introduce an over load to the software that may be even worst than on the memory, the garbage collector has his own thread which is not possible to control plus depending on the algorithm used by the gc could take more time and is consider very inefficient, you should check your software if it worst with the help of the gc because it is definitely broke, a good solution must not depend on the gc.