La matriz de bytes Java de 1 MB o más ocupa el doble de RAM

Ejecutar el siguiente código en Windows 10 / OpenJDK 11.0.4_x64 produce como salida used: 197y expected usage: 200. Esto significa que las matrices de 200 bytes de un millón de elementos ocupan aprox. 200 MB de RAM. Todo bien

Cuando cambio la asignación de la matriz de bytes en el código de new byte[1000000]a new byte[1048576](es decir, a 1024 * 1024 elementos), se produce como salida used: 417y expected usage: 200. ¿Que demonios?

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();
    }
}

Mirando un poco más profundo con visualvm, veo en el primer caso todo como se esperaba:

En el segundo caso, además de las matrices de bytes, veo el mismo número de matrices int que ocupan la misma cantidad de RAM que las matrices de bytes:

Estas matrices int, por cierto, no muestran que estén referenciadas, pero no puedo recolectarlas de forma basura ... (Las matrices de bytes muestran muy bien dónde están referenciadas).

¿Alguna idea de lo que está pasando aquí?

Lo que esto describe es el comportamiento listo para usar del recolector de basura G1, que por defecto suele ser "regiones" de 1 MB y se convirtió en un valor predeterminado de JVM en Java 9. La ejecución con otros GC habilitados proporciona números variables.

cualquier objeto que tenga más de la mitad del tamaño de una región se considera "enorme" ... Para los objetos que son un poco más grandes que un múltiplo del tamaño de la región del montón, este espacio no utilizado puede hacer que el montón se fragmente.

Corrí java -Xmx300M -XX:+PrintGCDetailsy muestra que el montón está agotado por las regiones gigantescas:

[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

Queremos que nuestro 1MiB byte[]sea ​​"menos de la mitad del tamaño de la región G1", por lo que agregar -XX:G1HeapRegionSize=4Mofrece una aplicación funcional:

[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

Descripción detallada de G1: https://www.oracle.com/technical-resources/articles/java/g1gc.html

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