Re: String intern question
Daniel Pitts wrote:
The problem with intern, is that interned strings live for the duration
of the system classloader (often the lifespan of the JVM instance),
which can lead to terrible memory leaks if used improperly.
Not quite true. Interned strings cache is now usually implemented in
soft references fashion, thus interned strings may become eligible for
garbage collection as soon as they are no longer strongly referenced.
It saves ram in the case where the same string may be duplicated.
An example where it wastes space is trivial to create.
That's trivial, however, your example do not causes that.
public static void main(String...args) {
for (int i = 0; i < Integer.MAX_VALUE; ++i) {
System.out.println(("foo" + i).intern());
}
}
Now, Integer.MAX_VALUE strings that will only appear once will be stored
indefinitely, leading to a memory leak, and probably an OOM on most
systems, where without the intern the program would run fine.
On most modern systems your example will run without any problems. Run
the following code to ensure that:
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.HashSet;
import java.util.Set;
public class InternedStringsCleanupTest {
public static void main(String[] args) {
ReferenceQueue<String> refq = new ReferenceQueue<String>();
Set<Reference<?>> refs = new HashSet<Reference<?>>();
int gced = 0;
for (int i = 0; i < Integer.MAX_VALUE; ++i) {
String foo = ("foo" + i).intern();
refs.add(new PhantomReference<String>(foo, refq));
int gcedInLastPass = 0;
for (Reference<?> ref; (ref = refq.poll()) != null;) {
refs.remove(ref);
++gcedInLastPass;
}
if (gcedInLastPass > 0) {
gced += gcedInLastPass;
System.out.println("after creation of " + foo + " "
+ gced + " (" + gcedInLastPass + " in last pass)"
+ " interned strings became unreachable");
}
}
}
}
piotr