Почему значения кеширования целочисленного класса находятся в диапазоне от -128 до 127?

Что касается моего предыдущего вопроса, почему == сравнения с Integer.valueOf (String) дают разные результаты для 127 и 128? , мы знаем, что у Integer classнего есть кеш, в котором хранятся значения между -128и 127.

Просто интересно, почему между -128 и 127 ?

В документации Integer.valueOf () указано, что он « кэширует часто запрашиваемые значения » . Но часто ли запрашиваются значения между -128и 127на самом деле? Я думал, что часто запрашиваемые значения очень субъективны.
Есть ли какая-то возможная причина?

Из документации также говорится: «..и может кэшировать другие значения вне этого диапазона »
Как это может быть достигнуто?

Просто интересно, почему между -128 и 127?

Можно кэшировать больший диапазон целых чисел , но, по крайней мере, числа между -128 и 127 должны быть кэшированы, потому что это предусмотрено Спецификацией языка Java (выделено мной):

Если упаковываемое значение p равно true, false, байту или символу в диапазоне от \ u0000 до \ u007f, либо int или короткому числу от -128 до 127 (включительно) , тогда пусть r1 и r2 будут результатами любые два боксерских преобразования p. Всегда бывает так, что r1 == r2.

Обоснование этого требования объясняется в том же параграфе:

В идеале упаковка данного примитивного значения p всегда давала бы идентичную ссылку . На практике это может оказаться невозможным при использовании существующих методов реализации. Приведенные выше правила представляют собой прагматический компромисс. Последнее предложение выше требует, чтобы определенные общие значения всегда помещались в неразличимые объекты. [...]

Это гарантирует, что в большинстве распространенных случаев поведение будет желаемым, без чрезмерного снижения производительности, особенно на небольших устройствах . Реализации с меньшим ограничением памяти могут, например, кэшировать все значения char и short, а также значения int и long в диапазоне от -32K до + 32K.

Как я могу кэшировать другие значения за пределами этого диапазона?

Вы можете использовать параметр -XX:AutoBoxCacheMaxJVM, который на самом деле не задокументирован в списке доступных параметров JVM Hotspot . Однако это упоминается в комментариях внутри Integerкласса около строки 590 :

Размер кеша может контролироваться -XX:AutoBoxCacheMax=<size>опцией.

Обратите внимание, что это зависит от реализации и может быть или недоступен на других JVM.

От -128 до 127 - размер по умолчанию. Но javadoc также говорит, что размер целочисленного кеша может контролироваться -XX:AutoBoxCacheMax=<size>опцией. Обратите внимание, что он устанавливает только высокое значение, низкое значение всегда -128. Эта функция была представлена ​​в версии 1.6.

Что касается того, почему от -128 до 127 - это диапазон значений байтов, и его естественно использовать для очень маленького кеша.

Причина кеширования небольших целых чисел, если вы об этом спрашиваете, заключается в том, что многие алгоритмы используют в своих вычислениях небольшие целые числа, поэтому, как правило, стоит избегать накладных расходов на создание объектов для этих значений.

Тогда возникает вопрос, какие целые числа кэшировать. Опять же, говоря в целом, частота, с которой используются постоянные значения, имеет тенденцию к уменьшению по мере увеличения абсолютного значения константы - каждый тратит много времени, используя значения 1, 2 или 10, относительно немногие используют значение 109 очень интенсивно; меньшее количество будет иметь производительность в зависимости от того, как быстро можно получить целое число для 722. Java решила выделить 256 слотов, охватывающих диапазон значений байта со знаком. Это решение могло быть основано на анализе программ, существовавших в то время, но столь же вероятно, что оно было чисто произвольным. Это разумный объем места для инвестиций, к нему можно быстро получить доступ (маска, чтобы узнать, находится ли значение в диапазоне кеша, затем быстрый поиск в таблице для доступа к кешу), и он определенно охватывает наиболее распространенные случаи.

Другими словами, я думаю, что ответ на ваш вопрос таков: «это не так субъективно, как вы думали, но точные границы в значительной степени являются практическим решением ... и экспериментальные доказательства показали, что это было достаточно хорошо. "

Максимальное максимальное целочисленное значение, которое можно кэшировать, можно настроить с помощью системного свойства ie java.lang.Integer.IntegerCache.high( -XX:AutoBoxCacheMax). Кеш реализован с помощью массива.

    private static class IntegerCache {
    static final int high;
    static final Integer cache[];

    static {
        final int low = -128;

        // high value may be configured by property
        int h = 127;
        if (integerCacheHighPropValue != null) {
            // Use Long.decode here to avoid invoking methods that
            // require Integer's autoboxing cache to be initialized
            int i = Long.decode(integerCacheHighPropValue).intValue();
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - -low);
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }

    private IntegerCache() {}
}

Когда вы сталкиваетесь с классом Integer и всегда помещаете в коробку в диапазоне от -128 до 127, всегда лучше преобразовать объект Integer в значение int, как показано ниже.

<Your Integer Object>.intValue()