Take the 2-minute tour ×

I was recently reading about all the JVM arguments available in JRE 6 [Java VM Options] and saw this :

-XX:+StringCache : Enables caching of commonly allocated strings.

Now I was always under the impression that Java kept a pool of interned (correct word?) Strings and when doing something like String concatenation with literals it was not creating new objects, but pulling them from this pool. Has anyone ever used this argument, or can explain why it would be needed?

EDIT: I attempted to run a benchmark, to see if this argument had any effect and was unable to get the Sun JVM to recognize it. This was with:

java version "1.6.0_11"  

So I'm not sure if this argument works at all.

share|improve this question
I think most string operations don't use interning. The interning is rather used by the JVM to store string values from the class files and avoid excessive memory consumption because of duplicates. –  kd304 Jun 26 '09 at 16:17
Great question. The sun docs are very unclear here. However, docs on interning are clear that it only operates under specific circumstances (string literals) so perhaps the JVM arg applies this behavior in a wider set of circumstances. –  Steve B. Jun 26 '09 at 16:21
I can't find this option in the OpenJDK source. What do you suppose that means? –  Michael Myers Jun 26 '09 at 16:29
@mmyers: It is probably not supported in OpenJDK. Sun states: "Options that are specified with -XX are not stable and are not recommended for casual use. These options are subject to change without notice." –  James Van Huis Jun 26 '09 at 16:33
Perhaps a benchmark is in order? –  Gandalf Jun 26 '09 at 18:27
show 1 more comment

5 Answers

I believe when used with -XX:+AggressiveOpts it enables the same String objects to be returned when creating the String with the same text (though not through new String, of course). There is a profile phase where a cache is build up, and after a point the cache is switched to read only. It gets higher scores in certain benchmarks.

share|improve this answer
add comment

-XX:-UseStringCache works for me, strangely.

my jdk version should be 1.6.0_22

share|improve this answer
add comment

I too couldn't get the above to work, but the latest JBB @ spec.org shows it's use: -XX:-UseStringCache. I'll have to re-run benchmarks to see if it makes a difference (an XML heavy app).

share|improve this answer
add comment

I also have not been able to find a JVM which respects this setting; as commented the quality and thus usefulness of the documentation around JVM parameters is terrible, and yet for some reason seems to be an area where JVM vendors see room for competitive differentiation - although to be fair Oracle/Sun is by far the worst.

Anyhow if you find that your app in some particular area uses a small number of string values repeatedly then it is definitely sensible to use interning - by using the String.intern() method to return an intern-pool value. Note that you have to use the return value, this is not a side-effect on the original value.

As with all profiling/performance tweaks this needs to be done carefully with metrics and testing. It can be significant (has been for me) but if the pool of values is not small it degrades performance and you need to be aware that the pool of String values is held in the Perm Gen and so using it will affect memory usage, GC etc.

share|improve this answer
add comment
up vote 0 down vote accepted

I have not been able to find a single JVM that even accepts this supposed argument - so I guess there's not much else to say.

share|improve this answer
You need -XX:+AggressiveOpts to enable many of the weird options, -XX:+UseStringCache including. Here is ref: mail.openjdk.java.net/pipermail/jdk7-dev/2011-April/002024.html –  bestsss Mar 20 '13 at 6:46
add comment

Your Answer


