Garbage collection of String literals

Question

I am reading about Garbage collection and i am getting confusing search results when i search for String literal garbage collections.

I need clarification on following points:

1. If a string is defined as literal at compile time [e.g: String str = "java"] then will it be garbage collected?

2. If use intern method [e.g: String str = new String("java").intern()] then will it be garbage collected? Also will it be treated differently from String literal in point 1.

3. Some places it is mentioned that literals will be garbage collected only when String class will be unloaded? Does it make sense because I don't think String class will ever be unloaded.

Solution 1

If a string is defined as literal at compile time [e.g: String str = "java";] then will it be garbage collected?

Probably not. The code objects will contain one or more references to the String objects that represent the literals. So as long as the code objects are reachable, the String objects will be to.

It is possible for code objects to become unreachable, but only if they were dynamically loaded ... and their classloader is destroyed.

If I use the intern method [e.g: String str = new String("java").intern()] then will it be garbage collected?

The object returned by the intern call will be the same object that represents the "java" string literal. (The "java" literal is interned at class loading time. When you then intern the newly constructed String object in your code snippet, it will lookup and return the previously interned "java" string.)

However, interned strings that are not identical with string literals can be garbage collected once they become unreachable. The PermGen space is garbage collected on all recent HotSpot JVMs. (Prior to Java 8 ... which drops PermGen entirely.)

Also will it be treated differently from string literal in point 1.

No ... because it is the same object as the string literal.

And indeed, once you understand what is going on, it is clear that string literals are not treated specially either. It is just an application of the "reachability" rule ...

Some places it is mentioned that literals will be garbage collected only when String class will be unloaded? Does it make sense because I don't think the String class will ever be unloaded.

You are right. It doesn't make sense. The sources that said that are incorrect. (It would be helpful if you posted a URL so that we can read what they are saying for ourselves ...)

Solution 2

Under normal circumstances, string literals and classes are all allocated into the JVM's permanent generation ("PermGen"), and usually won't ever be collected. Strings that are interned (e.g. mystring.intern()) are stored in a memory pool owned by the String class in permgen, and it was once the case that aggressive interning could cause a space leak because the string pool itself held a reference to every string, even if no other references existed. Apparently this is no longer true, at least as of JDK 1.6 (see, e.g., here).

For more on permgen, this is a decent overview of the topic. (Note: that link goes to a blog associated with a product. I don't have any association with the blog, the company, or the product, but the blog entry is useful and doesn't have much to do with the product.)

Comments

[Lokesh]

Can you give me an example where String can be unloaded? As i believe String literals must be used within java classes also and as String literals are constants, unloading might need unloading of CLassLoader as per my knowledge. Do you agree?

[fredrik]

A string literal cannot, to my knowledge be unloaded programatically. They will be unloaded, or destroyed, when the program terminates.

[Stephen C]

This is incorrect. The PermGen space >>is<< garbage collected.

[jacobm]

You are right of course. My intent was just to say that data allocated into permgen won't get GC'ed under normal circumstances, but I misphrased. Slightly rephrased.

[jacobm]

Actually, digging deeper, I discovered that it's no longer true that interned strings don't get garbage collected. (This isn't because of permgen space, it's due to the implementation of String#intern.) Changing my answer to reflect that.

[Stephen C]

@fredrik - they can also be garbage collected if a class that has been dynamically loaded is unloaded. And that can happen while the JVM is running normally.

[fredrik]

@StephenC ok. Good to know.

[Mercenary]

For #1, When you say code objects that contain references to String literals, what are you referring to?

[Stephen C]

Somewhere in the code objects (bytecode or native compiled) there will be instructions that need to fetch the reference to the String object that correspond to the literal. Either the reference is embedded in the code itself, or it is stored in a private frame that is associated with the code. Either way, the reference is "reachable" so long as the code could be executed.

[Mercenary]

Thanks. And, is string intern pool part of the method area in JVM?

[Stephen C]

No. It is a separate data structure. But if you are really interested, I suggest you download the OpenJDK source code and examine it for yourself.

[Holger]

It was never true that interned strings don't get garbage collected.

[user207421]

The literal is always in the pool, by definition.

[Mukit09]

No, the literal isn't always in the pool. It may. Read this: docs.oracle.com/javase/8/docs/api/java/lang/… @user207421