Detect low available memory in Java

1. The default GC behavior between Java 8 and Java 11 is different. Tweaking GC parameters is one way to improve memory efficiency. In local tests, setting '-XX:+UseAdaptiveGCBoundary' in Java 8 caused OOM closer to heap memory limits.
2. -Xmx controls the maximum amount of memory which is allowed to be allocated for the heap. The initial heap size can be controlled via: -Xms. If both values are the same, then the heap size will be fixed to the value set.

..

To better understand the memory breakdown between JVM versions it may be helpful to look at some visualizations. The below charts show the memory breakdown as memory is allocated by a similar program to the one included above in Java 8 and Java 15 (source included below):

Legend Description for Charts:
1) Total Free - Free memory including already allocated free memory and memory which may still be requested from the system up to Max memory. (totFre in test)
2) JVM Allocated (Free) - The memory which is available for usage within the memory already allocated for the JVM (Total Memory above). (freMem in test)
3) JVM Allocated - The memory currently allocated for the JVM. This may vary as objects are created or more space is needed up to Max Memory. (totMem in test)
4) Max Memory - The maximum memory the JVM will allow itself to use. Can be configured via -Xmx flag. (maxMem in test)

..

Why the discrepancy between Java 8 and 15?

When Java 15 is configured to use the same garbage collector used in Java 8 (Parallel GC), the heap grows similarly to how it does in Java 8. One difference is that in Java 15, all memory is consumed before failing with Out of Memory. This suggests that both the GC mechanism and parameters used impact the amount by which the heap is grown when more heap space is needed and the total effective heap capacity which can be used. This is further evidenced by running the same test in Java 8 with Serial GC in which case all memory is properly used. In the sample test, configuring the Parallel GC to use '-XX:+UseAdaptiveGCBoundary' improved max memory utilization before failure.

..

Test Source:

    public static void main(String[] args)
    {
        long totalProgramAllocated = 0;
        Queue<byte[]> dataQueue = new LinkedList<>();
        while (true)
        {
            System.out.println("Total Allocated: " + (totalProgramAllocated >> 20));
            byte[] nextAllocatedChunk = createArray(25);
            dataQueue.add(nextAllocatedChunk);
            totalProgramAllocated += nextAllocatedChunk.length;
            System.out.println(new MemoryUsage());
        }
    }

    private static final Random random = new Random();
    private static byte[] createArray(int megabytes){ byte[] data = new byte[(1 << 20) * megabytes]; random.nextBytes(data); return data; }
    
    public static final class MemoryUsage
    {
        public final long maxMem = Runtime.getRuntime().maxMemory();
        public final long totMem = Runtime.getRuntime().totalMemory();
        public final long freMem = Runtime.getRuntime().freeMemory();
        public final long totFre = maxMem - (totMem - freMem);
        @Override public String toString(){ return String.join(",", Long.toString(maxMem), Long.toString(totMem), Long.toString(freMem), Long.toString(totFre)); }
    }