How unreferred values from string pool get removed?

Question

I'm curious how values from a string-pool get removed?

suppose:

String a = "ABC"; // has a reference of string-pool
String b = new String("ABC"); // has a heap reference

b = null;
a = null;

In case of GC, "ABC" from the heap gets collected but "ABC" is still in the pool (because its in permGen and GC would not affect it).

If we keep adding values like:

String c = "ABC"; // pointing to 'ABC' in the pool. 

for(int i=0; i< 10000; i++) {
  c = ""+i;
  // each iteration adds a new value in the pool. Previous values don't have a pointer.
}

What I want to know is:

Will the pool remove values that are not referred to? If not, it means that the pool is eating up unnecessary memory.
What is the point then because the JVM is using the pool?
When could this be a performance risk?

Only `"ABC"` and `""` (second example) are permanent I suspect, but I'm no expert. — Reut Sharabani, Sep 11 '15 at 14:54
`c` isn't in the pool, and strings are immutable. You're creating a new string each time you concatenate, and those aren't in the pool. — Dave Newton, Sep 11 '15 at 14:55
all string literal goes in pool. C will be in pool. if we create Object with new keyword. it goes in heap — Muneeb Nasir, Sep 11 '15 at 14:57
Your confusion is with adding strings. It's just like using the `new` keyword in that aspect. — Reut Sharabani, Sep 11 '15 at 14:58
nope. I disagree with you. you can test by comparig them like this. String a = "ABC"; String b ="ABC"+"D"; String c = "ABCD"; c==b // true. because pointing to same reference in pool — Muneeb Nasir, Sep 11 '15 at 15:02
if you create String with new keyword, it holds heap reference. — Muneeb Nasir, Sep 11 '15 at 15:05
This looks like an optimization ("ABC"+"D"). I'd suggest creating strings in two loops and then comparing them. That's harder to optimize out :-) — Reut Sharabani, Sep 11 '15 at 15:08
@MuneebNasir `c` initially *references* a string in the pool, then doesn't. Your example is poor, because Java will concatenate during compilation. — Dave Newton, Sep 11 '15 at 16:48
FYI, JDK 8, and presumably above, no longer has a `PermGen`. — Jason, Sep 11 '15 at 18:27

score 4 · Accepted Answer · edited May 23 '17 at 12:03

As part of this code

String c = "ABC"; // pointing to 'ABC' in pool. 

for(int i=0; i< 10000; i++) {
  c = ""+i; // each iteration add new value in pool. and pervious values has no pointer  

}

Only two String objects will be in the pool, the two that come from the two String literals, "ABC" and "". Every other String created from the concatenation will be a regular object with regular GC behavior, ie. candidate for collection when they are no longer reachable.

The String values coming from String literals in the pool will not get collected as they are always reachable (YMMV with class loaders). String objects that are interned but don't come from literals should become candidates for GC in the regular manner.

How unreferred values from string pool get removed?

1 Answers1

Linked