Ein Java-Byte-Array von 1 MB oder mehr belegt das Doppelte des Arbeitsspeichers

Das Ausführen des folgenden Codes unter Windows 10 / OpenJDK 11.0.4_x64 erzeugt als Ausgabe used: 197und expected usage: 200. Dies bedeutet, dass 200-Byte-Arrays mit einer Million Elementen ca. 200 MB RAM. Alles ist gut.

Wenn ich die Byte-Array-Zuordnung im Code von new byte[1000000]auf new byte[1048576](dh auf 1024 * 1024 Elemente) ändere , wird als Ausgabe used: 417und ausgegeben expected usage: 200. Was zum Teufel?

import java.io.IOException;
import java.util.ArrayList;

public class Mem {
    private static Runtime rt = Runtime.getRuntime();
    private static long free() { return rt.maxMemory() - rt.totalMemory() + rt.freeMemory(); }
    public static void main(String[] args) throws InterruptedException, IOException {
        int blocks = 200;
        long initiallyFree = free();
        System.out.println("initially free: " + initiallyFree / 1000000);
        ArrayList<byte[]> data = new ArrayList<>();
        for (int n = 0; n < blocks; n++) { data.add(new byte[1000000]); }
        System.gc();
        Thread.sleep(2000);
        long remainingFree = free();
        System.out.println("remaining free: " + remainingFree / 1000000);
        System.out.println("used: " + (initiallyFree - remainingFree) / 1000000);
        System.out.println("expected usage: " + blocks);
        System.in.read();
    }
}

Wenn ich mit visualvm etwas tiefer schaue, sehe ich im ersten Fall alles wie erwartet:

Im zweiten Fall sehe ich zusätzlich zu den Byte-Arrays die gleiche Anzahl von int-Arrays, die dieselbe Menge an RAM belegen wie die Byte-Arrays:

Diese int-Arrays zeigen übrigens nicht, dass auf sie verwiesen wird, aber ich kann sie nicht mit Müll sammeln ... (Die Byte-Arrays zeigen genau, wo sie referenziert werden.)

Irgendwelche Ideen, was hier passiert?

Dies beschreibt das Out-of-the-Box-Verhalten des G1-Garbage Collectors, das normalerweise standardmäßig 1 MB "Regionen" verwendet und in Java 9 zu einem JVM-Standard wird. Wenn andere GCs aktiviert sind, ergeben sich unterschiedliche Zahlen.

Jedes Objekt, das mehr als eine halbe Regionsgröße hat, wird als "riesig" betrachtet. Bei Objekten, die nur geringfügig größer als ein Vielfaches der Größe der Heap-Region sind, kann dieser nicht verwendete Speicherplatz dazu führen, dass der Heap fragmentiert wird.

Ich bin gelaufen java -Xmx300M -XX:+PrintGCDetailsund es zeigt, dass der Haufen von riesigen Regionen erschöpft ist:

[0.202s][info   ][gc,heap        ] GC(51) Old regions: 1->1
[0.202s][info   ][gc,heap        ] GC(51) Archive regions: 2->2
[0.202s][info   ][gc,heap        ] GC(51) Humongous regions: 296->296
[0.202s][info   ][gc             ] GC(51) Pause Full (G1 Humongous Allocation) 297M->297M(300M) 1.935ms
[0.202s][info   ][gc,cpu         ] GC(51) User=0.01s Sys=0.00s Real=0.00s
...
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

Wir möchten, dass unser 1MiB byte[]"weniger als die Hälfte der Größe der G1-Region" beträgt, sodass das Hinzufügen -XX:G1HeapRegionSize=4Meine funktionale Anwendung bietet:

[0.161s][info   ][gc,heap        ] GC(19) Humongous regions: 0->0
[0.161s][info   ][gc,metaspace   ] GC(19) Metaspace: 320K->320K(1056768K)
[0.161s][info   ][gc             ] GC(19) Pause Full (System.gc()) 274M->204M(300M) 9.702ms
remaining free: 100
used: 209
expected usage: 200

Ausführliche Übersicht über G1: https://www.oracle.com/technical-resources/articles/java/g1gc.html

Crushing Detail von G1: https://docs.oracle.com/de/java/javase/13/gctuning/garbage-first-garbage-collector-tuning.html#GUID-2428DA90-B93D-48E6-B336-A849ADF1C552