How to efficiently manage memory using Strings?

Question

Consider a sample piece of code.

public void testString()
{     
    int i = 0;
    while(i < 100000000)
    {
        String s ="Hi hello bye" +i;
        i++;          
    }
}

In each iteration, a new String is created and its value is no longer needed for the next iteration. I tried printing the memory consumed pre and post this testString() functionality. Here are their values.

Before invoking testString():

Total Memory: 91684864 (87.4375 MB)
Max Memory:   1360855040 (1297.8125 MB)
Free Memory:  72163552 (68.82052612304688 MB)

After invoking testString():
Total Memory: 424280064 (404.625 MB)
Max Memory:   1360855040 (1297.8125 MB)
Free Memory:  171766816 (163.80960083007812 MB).

I see a large amount of memory being used and am afraid JVM Heap may go out of bounds due to the current way of handling Strings. The String generated for iteration 1 is no longer needed in iteration 2 and its storage space can be freed. I believe that is not happening here.

I tried using StringBuffer and StringBuilder objects and there seems a very marginal improvement in the memory usage.

Kindly assist me a better and optimal approach.

Answer 1

The String generated for iteration 1 is no longer needed in iteration 2 and its storage space can be freed. I believe that is not happening here.

It definitely is happening.

You're creating 100 million strings, each of which is at least 13 characters - and most of which will be about 20 characters. Each string consists of an object (which has overhead) and a char[] - so I'd guess at it taking around 60 bytes for a 20-character string.

If garbage collection weren't being effective, 100 million objects requiring 60 bytes each would require 6GB - whereas you're seeing a total memory which is only about 300MB larger than it was to start with.

The strings are being collected - just not immediately.

You haven't told us what you need to do with the strings in your real code (I'm assuming there's a real motivation for this) - assuming you actually need a string in each iteration of a loop, I don't think using StringBuilder is going to help you. If you only need the data is a StringBuilder then you can make it a lot more efficient, but it's rare that you create a StringBuilder but don't call toString on it.

Answer 2

What will happen on the first run

JVM runs the code, generates the strings, and at certain intervals the Garbage Collector frees the used memory. Beside some wasted execution time, the program will run normally.

What will happen if the function is called frequently

JVM will begin to optimize the loop, realize that nothing is done with those strings ever and marks the entire function as dead code. Eventually calling the function will do literally nothing, as the JVM converted the content to a simple return

Kindly assist me a better and optimal approach.

Since even the JVM has no clue what your code is supposed to do... what is it what you want to do? There might be an optimal solution for your actual problem at hand, that is very different from the code sample that you posted initially.

Answer 3

It depends on how you used StringBuilder. This

    StringBuilder sb = new StringBuilder("");
    while (i < 100000000) {
        sb.delete(0, sb.length());
        sb.append("Hi hello bye").append(i);
        i++;
    }

will be much more efficient both in memory consumption and speed

Answer 4

String is immutable, when you going to add a string continuously which is create a string object for every iteration, so memory has been exceed. if you use StringBuilder, it works in single object even it handles more than one iteration is happen. StringBuilder is mutable.

StringBuilder iter = new StringBuilder("");
while (i < 100000000) 
{
    iter.delete(0, iter.length());
    iter.append("Hi hello bye").append(i);
    i++;
} 

Answer 5

The JVM should never run out of heap memory from unreferenced objects, such as the strings in your example program, because before it throws an OutOfMemory exception, it will run garbage collection. See the semantics of this exception from the Java Virtual Machine Specification, section 6.3:

OutOfMemoryError: The Java Virtual Machine implementation has run out of either virtual or physical memory, and the automatic storage manager was unable to reclaim enough memory to satisfy an object creation request.

Answer 6

Usage of string builders is the best option you have. Since the number of strings/string builders required by you are huge in number, you can not expect JVM to virtually avoid using much of a memory in any case. Referring to your statistics above:

With use of string: % of free memory on total memory is 40.48% ((163.80960083007812 MB/404.625 MB )*100).

With use of string builders: % of free memory on total memory is 69.35 % ((252.659 MB/364.3125 MB)*100), which is quite a significant improvement. Also, usage of the above variable is only inside the scope of loop, therefore JVM's garbage collector will run to clear the memory once required.

Answer 7

Since scope of variable is just for the iteration of while loop, so here you don't need to worry about memory overflow as on next Garbage Collector execution it will free all the memory:

while(i < 100000000)
{
    String s ="Hi hello bye" +i;
    i++;          
}// no more required the s afterward

In each iteration String s will create a new object and but previous one is not required now, so it is in memory until Garbage collector clean it.