Integer的缓存机制

宋正兵 on 2020-10-28

在之前我们先了解一个小知识。

equals() 和 == 的区别

  • 功能方面:
    • “==”是判断两个变量或者实例是不是指向同一个内存空间
    • “equals”是判断两个变量或实例所指向的内存空间的值是不是相同
  • 定义方面:
    • “==”在Java中是一个运算符
    • “equals”在Java中是一个方法

然后我们再来观察一个有意思的现象:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int a = 127;
int b = 127;
System.out.println(a == b); // true
a = 128;
b = 128;
System.out.println(a == b); // true

Integer c = 127;
Integer d = 127;
System.out.println(c == d); // true
c = 128;
d = 128;
System.out.println(c == d); // false
System.out.println(c.equals(d)); // true

前面都很好理解,但是往下一看,Integer的128为什么不等于128了呢?通过阅读源码得知,Integer类内部通过静态内部类,提供了一个缓存池,范围在-128~127之间,如果超过这个范围的Integer值都是new出来的对象,比较的话肯定会出错!

Integer的缓存机制

Integer缓存是一个有助于节省内存、提高性能的特性。

Integer的缓存机制:Integer对小数据(-128~127),在JVM初始化的时候,数据在-128~127之间的数字便被缓存到了本地内存中,如果初始化这个范围的数字,会直接从内存中取出,不需要新建一个对象。

1
2
3
4
5
6
7
8
// 装箱
public static Integer valueOf(int i) {
// 在缓存范围内
if (i >= IntegerCache.low && i <= IntegerCache.high)
// 从缓存中取出来
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
private static class IntegerCache {
// 缓存数组的大小为 high - low + 1
static final int low = -128;
static final int high;
static final Integer[] cache;
static Integer[] archivedCache;

static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
h = Math.max(parseInt(integerCacheHighPropValue), 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;

// Load IntegerCache.archivedCache from archive, if possible
VM.initializeFromArchive(IntegerCache.class);
int size = (high - low) + 1;

// Use the archived cache if it exists and is large enough
if (archivedCache == null || size > archivedCache.length) {
Integer[] c = new Integer[size];
int j = low;
for(int i = 0; i < c.length; i++) {
c[i] = new Integer(j++);
}
archivedCache = c;
}
cache = archivedCache;
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}

private IntegerCache() {}
}

通过源码我们能看到,最大值映射到java.lang.Integer.IntegerCache.high,可以使用JVM的启动参数设置最大值,修改缓存的大小。

之所以选择-128到127这个范围,是因为这个范围的整数值是使用最广泛的。

其他对象的缓存

这种缓存机制不仅适用于Integer对象,针对所有整数类型的类都有类似的缓存机制。

  • Byte类:ByteCache,固定范围-128~127
  • Short类:ShortCache,固定范围-128~127
  • Long类:LongCache,固定范围-128~127
  • Character类:CharacterCache,固定范围0~127

也就是说除了Integer类可以通过参数改变范围,其他的都不行。