9

I found that using String.substring is known for memory issues related to String.split.

Is there a memory leak in using String.split?

If yes what is the work-around for it?

Following link show correct usage of substring in Java.

https://bugs.java.com/bugdatabase/view_bug?bug_id=4513622

One more blog which talk about possible MLK in substring.

http://nflath.com/2009/07/the-dangers-of-stringsubstring/

Improve this question
5
  • 6
    I realise english is probably not your first language, but this question makes no sense. Give us some context please. Commented May 19, 2011 at 9:19
  • i don't think that such commonly used methods had memory leaks, which exist since early versions of Java. But if you found a memory leak, provide some informations. Commented May 19, 2011 at 9:21
  • 1
    can you give us links about the known work-around you mentioned? Commented May 19, 2011 at 9:21
  • 1
    following is the comment i see from some user I would also put word for mentioning this problem in the JavaDocs. I experienced similar problem, but with String.split rather than String.substing, which works the same way (the split chunks reference the original string's storage), and it took me a while to find out the problem Commented May 19, 2011 at 9:27
  • 1
    Java optimises substring/split for fast String creation, if the original string requires large amounts of memory you have to use copies obtained by new String(...) instead. Java can't do this for you since the right behaviour depends on how you use the Strings. Commented May 19, 2011 at 9:37

1 Answer 1

Reset to default
11

Update: Behavior has changed in 1.7.0_06: See this article: Changes to String internal representation made in Java 1.7.0_06 at java-performance.info.

As pointed out by @finnw there is indeed kind of a memory leak lurking around when using String.substring. The reason is that String.substring only returns a view of a portion of the given string, i.e., the underlying string is still kept in memory.

To force the creation of a new string, unrelated to the source, you'll have to use the new keyword. I.e., you'll have to do for instance

String[] parts = orig.split(";");
//String mySubstring = parts[i];               // keeps orig from being GC'd
String mySubstring = new String(parts[i]);     // creates a new string.

or, perhaps more direct

String mySubstring = new String(orig.split(";")[i]);

I must say that this behavior seems "unnecessary" to me. It should be solvable using weak references or some other technique. (Especially considering that String is already a special class, part of the Java language specification.)

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

Thanks, But is there any issue with using split ??
No. If you detach the strings you want to keep using new String(...) you should be just fine.
I imagine that the reason that weak references aren't used is because they are expensive for the garbage collector to deal with. This is one of those unfortunate cases where something that is usually a significant optimization is sometimes the reverse.
Right. Still though, I'm surprised that they haven't solved this by some other means, using for instance a JVM internal hack if so needed. (Strings are part of the JLS already anyway).
@aioobe - 1) what technique would this internal hack use? 2) while Strings have a special status in the JLS, I believe that in recent HotSpot JVMs they are almost entirely implemented in Java. (String.intern is the only exception, I think.)
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.