Question

I heard that string object pool exists in the PermGC and when a string intern is executed, it checks the pool first to see if an equivalent string object exists, if it does not exist, it creates one and returns a reference to the pooled instance.

But here is my first question.

I think that object is created on the heap, especially in the young generation first. If it survives during few garbage collections, it moves to the old generation. can anybody explain how the string object goes to the pool that exists in the Perm GC?

second question:

String s = “test”;
s = “test1”;

If i reassign “test1” to a reference s and continue to use “test1”, does it mean that “test” (created on the young generation) will be garbage collected?

third question:
How is the string object pool related to the runtime constant pool?

Thanks.

Answer 1

What makes you think the interned String first goes to the young generation? The String#intern() method is a native method. It’s certainly very possible for an implementation to move it right into the permgen.

Second question: if there’s no other references to that "test" String instance, it’s eligible for garbage collection. Same story if it’s interned. Even an interned String that no longer has any active references can be garbage collected. This might not have been the case in older JVMs, though. And it can be implementation-specific, I guess.

As for the third question, I do not know. All I know is that String literals from source code are placed into the same pool. If you were to construct a String that’s equal to a String constant from source and then intern it, you’d be returned the instance that was used to represent the constant. Think of this as String literals having been interned right away.

EDIT: just read your initial few sentences again and I think I see the reason for the confusion. When you call intern() on a String, and no equal String is in the pool yet, then it’s not first gonna construct an equivalent String. It’ll just move the instance you called intern() on to the pool rather than returning a new reference. That’s how it’s stated in the JavaDoc.