java - minheapfreeratio - optifine jvm arguments

¿Por qué la JVM permite establecer el valor "alto" para IntegerCache, pero no el "bajo"?

Question

Todos sabemos que Java tiene una memoria caché para Integer (y algunos otros tipos) para el número en el rango [-128, 127] que se consideran "de uso común".

El caché está diseñado de la siguiente manera:

private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}

Sé que puedo extender el valor high al asignar un parámetro a la JVM:

java -Djava.lang.Integer.IntegerCache.high=xxxx Aclass.class

Lo que no entiendo es ¿por qué no podemos anular el valor low ?

Tenga en cuenta que no estaba tratando de encontrar una solución alternativa, pero en vez de eso, entiendo por qué no está permitido por algunas razones oscuras.

Answer 1

Descubrí que ya existe una RFP no resuelta en esto.

Joe Darcy comentó sobre el tema:

Es concebible que también sería útil almacenar en caché un mayor número de números negativos, pero hasta ahora no ha habido una necesidad apremiante de hacerlo.

Tenga en cuenta que la RFP ofrece una solución alternativa deficiente si alguna vez alguien estuvo interesado en usar esto antes de que se maneje:

No es posible una solución alternativa para aumentar el tamaño de la memoria caché aparte de Implementar su propia memoria caché y remitirse a esta antes de ir a la clase java.lang.Integer. Obviamente, esto no es bueno ya que requiere llamadas a otras clases en lugar del uso predeterminado de la llamada Integer.valueOf (int i) .