垃圾收集器，字符串和终结混乱

Question

So I was fooling around a little bit with the amount of time it takes to build Strings vs using StringBuilder and was also messing around a little with the garbage collector. For me as a first year CS student, the garbage collector is a little bit like magic too me where it just cleans up everything and "just works". I was a little confused when I came up with this:

public class Main
{

    public static void main(String[] args)
    {
        long time = System.currentTimeMillis();
        new Test();
        for (int i= 0; i < 10000; i++)
        {
            String s = "a";
            for (int c = 0; c < 26; c++)
            {
                s += (Character.toString((char) ('a' + c)));
                //s += "testttzzz";
            }
        }
        System.out.println(System.currentTimeMillis() - time);
    }

}

class Test
{
    @Override
    protected void finalize() throws Throwable
    {
        System.out.println("FINALIZE TEST!");
    }
}

Inside the code above, if I uncomment out the line 's += "testttzzz" the garbage collector will be called and it will output FINALIZE TEST! . However, if that line is commented out the garbage collector will not run while the program is running and wont output FINALIZE TEST! at all. Why is this?

Edit: I tried adding System.out.println(i); inside the first for loop so I can see when exactly System.gc() is being called. It seems that adding that line caused the garbage collector to not be ran at all anymore. I am really confused.

Edit2: If it makes a difference, I am using JRE 1.7.0_45 and using eclipse version 4.3.1 to compile the code

Edit3: I guess it just appears that the added time from the extra lines of code gives the garbage collector more time to run and allows finalize() to be called. Interesting nevertheless.

Edit4: Well, according to Jon Skeet that is not the case. The garbage collector is pretty interesting

Answer 1

Without the commented-out part you are only using about 260 KB payload memory. Including overhead you might get up to 1 MB scrapable data.

I ran your program and checked it against VisualVM to see what is happening.

The VM starts with a heap size of 63.5 MB, so it has that space before it would need to allocate new space. The program starts with a memory usage of about 6.5 MB, so just about 10% of the memory it has is used. During the course of the program the memory usage goes up to 8.1 MB, so I give you that, it was 1.6 MB up, but still, that is nothing. The VM has tons of space left. Running the GC now would be just a waste of CPU time.

I added an infinite loop at the end of the program to check if it's just that the program went down before the GC could kick in, but no, it wasn't, the GC did not run.

Next thing I did was uncommenting this line:

s += "testttzzz";

Now the memory usage went up just a tiny bit more, but seemingly just enough to make it above the "magic barrier" and the GC ran.

The GC has a few metrics that decide when it runs and those differ from one VM running Java to another. Some of them are:

• Percentage of heap memory used
• Growth rate of used memory
• Free memory that can be allocated for the heap
• Current CPU usage

You said

"the garbage collector is a little bit like magic too me where it just cleans up everything and "just works"."

And that is just about how it should be. In Java the implementation of the GC is up to the person who created the VM. There is no standard about when it has to run. There is the method System.gc(), but not even that one forces the GC to run, but merely "suggests" that now would be a good time to run the GC. Even if you use the same VM on a different system it can act completely different. As an example: I've got an Windows 7 64-Bit system with 4 GB RAM running an 32-Bit Java VM. My default maximum heap size is 903.12 MB. My wife has an Windows 8 64-Bit system with 4 GB RAM running the same 32-Bit Java VM. Her default maximum heap size is only 247.5 MB! This means, the GC would be a lot lazier on my system than on my wife's.

As a programmer you can trust the GC to do it's job (clear up memory so you have enough memory for your program) but do not make any parts of your program depend on the GC performing in any certain way, because it doesn't have to and it probably will not.