堆：幸存者空间

Question

I wrote a sample java application which allocates memory and then running forever.
why is the memory used by the survivor space 0kbytes ?!

    List<String> stringlist = new ArrayList<String>();

    while (true) {
        stringlist.add("test");
        if (stringlist.size() >= 5000000)
            break;
    }

    while (true)
        for (String s : stringlist);

Answer 1

Because "test" is a String literal it will end up in permanent memory not heap. Memory size of objects you create is 5000000 + 4*2 ~ 5MB which will easily fit into Eden space.

Modify

stringlist.add("test");

to

stringlist.add(new String("test"));

and you will get 5000000 * 4 * 2 =38MB which most probably will still fit into Eden. You can either increase your list size or String length to make sure you have survivors.

Answer 2

"test" is a String literal and, regardless of how it's stored (this has changed during the Java development), the important point here is, that it is a single object .

Recall the Java Language Specification :

…a string literal always refers to the same instance of class String . This is because string literals - or, more generally, strings that are the values of constant expressions (§15.28) - are "interned" so as to share unique instances, using the method String.intern

So there are no new String s created within your loop as "test" always refers to the same String instance. The only heap change occurs when the ArrayList 's internal capacity is exhausted.

---

The memory finally required for the ArrayList 's internal array depends on the size of an object reference, usually it's 5000000*4 bytes for 32Bit JVMs and 64Bit JVMs with compressed oops and 5000000*8 bytes for 64Bit JVMs without compressed oops.

The interesting point here is described on www.kdgregory.com :

if your object is large enough, it will be created directly in the tenured generation. User-defined objects won't (shouldn't!) have anywhere near the number of members needed to trigger this behavior, but arrays will: with JDK 1.5, arrays larger than a half megabyte go directly into the tenured generation.

This harmonizes with these words found on oracle.com :

If survivor spaces are too small, copying collection overflows directly into the tenured generation.

which gives another reason why larger arrays might not show up in the survivor space. So it depends on the exact configuration whether they do not appear because the were copied from Eden space to Tenured Generation or were created in the Tenured Generation in the first place. But the result of not showing up in the survivor space is the same.

---

So when the ArrayList is created with its default capacity of 10 , the internal array is smaller than this threshold and so are the next ones to be created on each capacity enlargements. However, at the time the new array exceeds this threshold, all old ones are garbage and hence won't show up as “survivors”.

So at the end of the first loop you have only one remaining array which has a size exceeding the threshold by far and hence bypassed the Survivor space. Your second loop does not add anything to the memory management. It creates temporary Iterator s but these never “survive”.