java - JDK 1.6及以上版本Integer类的缓存机制改变有什么好处？

Question

我发现缓存机制在jdk 1.6或以上的jdk版本中得到了改进。

在jdk 1.5中Integer中的缓存数组是固定的，参见

  static final Integer cache[] = new Integer[-(-128) + 127 + 1];

在jdk 1.6或以上版本中，名为 getAndRemoveCacheProperties的方法 和一个 IntegerCache.high属性已添加到 Integer 类，

喜欢，

//java.lang.Integer.IntegerCache.high 属性的值(在 VM 初始化期间获得)

private static String integerCacheHighPropValue;

static void getAndRemoveCacheProperties() {
    if (!sun.misc.VM.isBooted()) {
        Properties props = System.getProperties();
        integerCacheHighPropValue =
            (String)props.remove("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null)
            System.setProperties(props);  // remove from system props
    }
}

通过此更改，允许为缓存配置最高值并使用新的缓存范围。 ( -128 <= cachedValue <= highestValue )。

*这是我的问题:*

Q#1 为什么缓存范围在jdk 1.5或jdk 1.6及以上版本默认缓存使用[-128 ~ 127]？难道只是支持bytes和 char '\u0000'~ 'u007f' ？

Q#2 jdk 1.6及以上版本缓存范围指定大值有什么好处？什么样的应用或场景适合我们做？

请帮我解决这些问题。非常感谢您。

下面是 Integer 类中 IntegerCache 和 valueOf(int i) 的源代码。仅供引用。

jdk 1.5

private static class IntegerCache {
private IntegerCache(){}

static final Integer cache[] = new Integer[-(-128) + 127 + 1];

static {
    for(int i = 0; i < cache.length; i++)
    cache[i] = new Integer(i - 128);
}
}


public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache 
    return IntegerCache.cache[i + offset];
}
    return new Integer(i);
}

jdk 1.6

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


public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

Answer 1

Q#1 Why the cache range is using [-128 ~ 127] in jdk 1.5

因为这是他们设计 JDK 1.5 的方式。

or default cache of jdk 1.6 or above version?

因为这是他们设计 JDK 1.6 的方式。

Is it just to support bytes and char '\u0000'~ 'u007f' ?

在 JDK 1.5 中，是，在 JDK 1.6+ 中，否。

Q#2 What is the advantage to specify a high value for cache range in jdk 1.6 or above version?

以便缓存更大范围内的值。

What kind of appilication or sceen is suitable for us to do so?

频繁使用范围更广的值的应用程序。