（全网最详细最有深度）超过1W字深度剖析JVM常量池

字符串常量池存储在堆内存空间中，创建形式如下图所示。

当使用String a=“Hello”这种方式创建字符串对象时，JVM首先会先检查该字符串对象是否存在与字符串常量池中，如果存在，则直接返回常量池中该字符串的引用。否则，会在常量池中创建一个新的字符串，并返回常量池中该字符串的引用。（这种方式可以减少同一个字符串被重复创建，节约内存，这也是享元模式的体现）。

如下图所示，如果再通过String c=“Hello”创建一个字符串，发现常量池已经存在了Hello这个字符串，则直接把该字符串的引用返回即可。（String里面的享元模式设计）

当使用String b=new String(“Mic”)这种方式创建字符串对象时，由于String本身的不可变性（后续分析），因此在JVM编译过程中，会把Mic放入到Class文件的常量池中，在类加载时，会在字符串常量池中创建Mic这个字符串。接着使用new关键字，在堆内存中创建一个String对象并指向常量池中Mic字符串的引用。

如下图所示，如果再通过new String(“Mic”)创建一个字符串对象，此时由于字符串常量池已经存在Mic，所以只需要在堆内存中创建一个String对象即可。

简单总结一下：JVM之所以单独设计字符串常量池，是JVM为了提高性能以及减少内存开销的一些优化：

String对象作为Java语言中重要的数据类型，是内存中占据空间最大的一个对象。高效地使用字符串，可以提升系统的整体性能。
创建字符串常量时，首先检查字符串常量池是否存在该字符串，如果有，则直接返回该引用实例，不存在，则实例化该字符串放入常量池中。

字符串常量池是JVM所维护的一个字符串实例的引用表，在HotSpot VM中，它是一个叫做StringTable的全局表。在字符串常量池中维护的是字符串实例的引用，底层C++实现就是一个Hashtable。这些被维护的引用所指的字符串实例，被称作”被驻留的字符串”或”interned string”或通常所说的”进入了字符串常量池的字符串”!

封装类常量池

除了字符串常量池，Java的基本类型的封装类大部分也都实现了常量池。包括Byte,Short,Integer,Long,Character,Boolean

注意，浮点数据类型Float,Double是没有常量池的。

封装类的常量池是在各自内部类中实现的，比如IntegerCache(Integer的内部类)。要注意的是，这些常量池是有范围的：

Byte,Short,Integer,Long : [-128~127]
Character : [0~127]
Boolean : [True, False]

测试代码如下：

public static void main(String[] args) {

Character a=129;

Character b=129;

Character c=120;

Character d=120;

System.out.println(a==b);

System.out.println(c==d);

System.out.println(“…integer…”);

Integer i=100;

Integer n=100;

Integer t=290;

Integer e=290;

System.out.println(i==n);

System.out.println(t==e);

}

运行结果：

false

true

…integer…

true

false

封装类的常量池，其实就是在各个封装类里面自己实现的缓存实例（并不是JVM虚拟机层面的实现），如在Integer中，存在IntegerCache，提前缓存了-128~127之间的数据实例。意味着这个区间内的数据，都采用同样的数据对象。这也是为什么上面的程序中，通过==判断得到的结果为true。

这种设计其实就是享元模式的应用。

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

}

封装类常量池的设计初衷其实String相同，也是针对频繁使用的数据区间进行缓存，避免频繁创建对象的内存开销。

关于字符串常量池的问题探索

在上述常量池中，关于String字符串常量池的设计，还有很多问题需要探索：

如果常量池中已经存在某个字符串常量，后续定义相同字符串的字面量时，是如何指向同一个字符串常量的引用？也就是下面这段代码的断言结果是true。

String a=“Mic”;

String b=“Mic”;

assert(a==b); //true

字符串常量池的容量到底有多大？
为什么要设计针对字符串单独设计一个常量池？

为什么要设计针对字符串单独设计一个常量池？

首先，我们来看一下String的定义。

public final class String

implements java.io.Serializable, Comparable, CharSequence {

/** The value is used for character storage. */

private final char value[];

/** Cache the hash code for the string */

private int hash; // Default to 0

}

从上述源码中可以发现。

String这个类是被final修饰的，代表该类无法被继承。
String这个类的成员属性value[]也是被final修饰，代表该成员属性不可被修改。

因此String具有不可变的特性，也就是说String一旦被创建，就无法更改。这么设计的好处有几个。

方便实现字符串常量池：在Java中，由于会大量的使用String常量，如果每一次声明一个String都创建一个String对象，那将会造成极大的空间资源的浪费。Java提出了String pool的概念，在堆中开辟一块存储空间String pool，当初始化一个String变量时，如果该字符串已经存在了，就不会去创建一个新的字符串变量，而是会返回已经存在了的字符串的引用。如果字符串是可变的，某一个字符串变量改变了其值，那么其指向的变量的值也会改变，String pool将不能够实现！
线程安全性，在并发场景下，多个线程同时读一个资源，是安全的，不会引发竞争，但对资源进行写操作时是不安全的，不可变对象不能被写，所以保证了多线程的安全。
保证 hash 属性值不会频繁变更。确保了唯一性，使得类似HashMap容器才能实现相应的key-value缓存功能，于是在创建对象时其hashcode就可以放心的缓存了，不需要重新计算。这也就是Map喜欢将String作为Key的原因，处理速度要快过其它的键对象。所以HashMap中的键往往都使用String。

注意，由于String的不可变性可以方便实现字符串常量池这一点很重要，这时实现字符串常量池的前提。

字符串常量池，其实就是享元模式的设计，它和在JDK中提供的IntegerCache、以及Character等封装对象的缓存设计类似，只是String是JVM层面的实现。

字符串的分配，和其他的对象分配一样，耗费高昂的时间与空间代价。JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化。为了减少在JVM中创建的字符串的数量，字符串类维护了一个字符串池，每当代码创建字符串常量时，JVM会首先检查字符串常量池。如果字符串已经存在池中，就返回池中的实例引用。如果字符串不在池中，就会实例化一个字符串并放到池中。Java能够进行这样的优化是因为字符串是不可变的，可以不用担心数据冲突进行共享。

我们把字符串常量池当成是一个缓存，通过双引号定义一个字符串常量时，首先从字符串常量池中去查找，找到了就直接返回该字符串常量池的引用，否则就创建一个新的字符串常量放在常量池中。

常量池有多大呢?

我想大家一定和我一样好奇，常量池到底能存储多少个常量？

前面我们说过，常量池本质上是一个hash表，这个hash表示不可动态扩容的。也就意味着极有可能出现单个 bucket 中的链表很长，导致性能降低。

在JDK1.8中，这个hash表的固定Bucket数量是60013个，我们可以通过下面这个参数配置指定数量

-XX:StringTableSize=N

可以增加下面这个虚拟机参数，来打印常量池的数据。

-XX:+PrintStringTableStatistics

增加参数后，运行下面这段代码。

public class StringExample {

private int value = 1;

public final static int fs=101;

public static void main(String[] args) {

final String a=“ab”;

final String b=“a”+“b”;

String c=a+b;

}

在JVM退出时，会打印常量池的使用情况如下:

SymbolTable statistics:

Number of buckets : 20011 = 160088 bytes, avg 8.000

Number of entries : 12192 = 292608 bytes, avg 24.000

Number of literals : 12192 = 470416 bytes, avg 38.584

Total footprint : = 923112 bytes

Average bucket size : 0.609

Variance of bucket size : 0.613

Std. dev. of bucket size: 0.783

Maximum bucket size : 6

StringTable statistics:

Number of buckets : 60013 = 480104 bytes, avg 8.000

Number of entries : 889 = 21336 bytes, avg 24.000

Number of literals : 889 = 59984 bytes, avg 67.474

Total footprint : = 561424 bytes

Average bucket size : 0.015

Variance of bucket size : 0.015

Std. dev. of bucket size: 0.122

Maximum bucket size : 2

可以看到字符串常量池的总大小是60013，其中字面量是889。

字面量是什么时候进入到字符串常量池的

字符串字面量，和其他基本类型的字面量或常量不同，并不会在类加载中的解析（resolve）阶段填充并驻留在字符串常量池中，而是以特殊的形式存储在运行时常量池（Run-Time Constant Pool）中。而是只有当此字符串字面量被调用时（如对其执行ldc字节码指令，将其添加到栈顶），HotSpot VM才会对其进行resolve，为其在字符串常量池中创建对应的String实例。

具体来说，应该是在执行ldc指令时（该指令表示int、float或String型常量从常量池推送至栈顶）

在JDK1.8的HotSpot VM中，这种未真正解析（resolve）的String字面量，被称为pseudo-string，以JVM_CONSTANT_String的形式存放在运行时常量池中，此时并未为其创建String实例。

在编译期，字符串字面量以"CONSTANT_String_info"+"CONSTANT_Utf8_info"的形式存放在class文件的常量池（Constant Pool）中；

在类加载之后，字符串字面量以"JVM_CONSTANT_UnresolvedString(JDK1.7)"或者"JVM_CONSTANT_String(JDK1.8)"的形式存放在运行时常量池（Run-time Constant Pool）中；

在首次使用某个字符串字面量时，字符串字面量以真正的String对象的方式存放在字符串常量池（String Pool）中。

通过下面这段代码可以证明。

public static void main(String[] args) {

String a =new String(new char[]{‘a’,‘b’,‘c’});

String b = a.intern();

System.out.println(a == b);

String x =new String(“def”);

String y = x.intern();

System.out.println(x == y);

}

使用new char[]{‘a’,’b’,’c’}构建的字符串，并没有在编译的时候使用常量池，而是在调用a.intern()时，将abc保存到常量池并返回该常量池的引用。

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》无偿开源威信搜索公众号【编程进阶路】
intern()方法

在Integer中的valueOf方法中，我们可以看到，如果传递的值i是在IntegerCache.low和IntegerCache.high范围以内，则直接从IntegerCache.cache中返回缓存的实例对象。

public static Integer valueOf(int i) {

if (i >= IntegerCache.low && i <= IntegerCache.high)

return IntegerCache.cache[i + (-IntegerCache.low)];

return new Integer(i);

}

那么，在String类型中，既然存在字符串常量池，那么有没有方法能够实现类似于IntegerCache的功能呢？

答案是：intern()方法。由于字符串池是虚拟机层面的技术，所以在String的类定义中并没有类似IntegerCache这样的对象池，String类中提及缓存/池的概念只有intern() 这个方法。

/**

Returns a canonical representation for the string object.
A pool of strings, initially empty, is maintained privately by the
class {@code String}.
When the intern method is invoked, if the pool already contains a
string equal to this {@code String} object as determined by
the {@link #equals(Object)} method, then the string from the pool is
returned. Otherwise, this {@code String} object is added to the
pool and a reference to this {@code String} object is returned.
It follows that for any two strings {@code s} and {@code t},
{@code s.intern() == t.intern()} is {@code true}
if and only if {@code s.equals(t)} is {@code true}.
All literal strings and string-valued constant expressions are
interned. String literals are defined in section 3.10.5 of the
The Java™ Language Specification.
@return a string that has the same contents as this string, but is

     guaranteed to be from a pool of unique strings.

public native String intern();

这个方法的作用是：去拿String的内容去Stringtable里查表，如果存在，则返回引用，不存在，就把该对象的"引用"保存在Stringtable表里。

比如下面这段程序：

public static void main(String[] args) {

String str = new String(“Hello World”);

String str1=str.intern();

String str2 = “Hello World”;

System.out.print(str1 == str2);

}

运行的结果为：true。

实现逻辑如下图所示，str1通过调用str.intern()去常量池表中获取Hello World字符串的引用，接着str2通过字面量的形式声明一个字符串常量，由于此时Hello World已经存在于字符串常量池中，所以同样返回该字符串常量Hello World的引用，使得str1和str2具有相同的引用地址，从而运行结果为true。

总结：intern方法会从字符串常量池中查询当前字符串是否存在：

若不存在就会将当前字符串放入常量池中，并返回当地字符串地址引用。
如果存在就返回字符串常量池那个字符串地址。

注意，所有字符串字面量在初始化时，会默认调用intern()方法。

这段程序，之所以a==b，是因为声明a时，会通过intern()方法去字符串常量池中查找是否存在字符串Hello，由于不存在，则会创建一个。同理，变量b也同样如此，所以b在声明时，发现字符常量池中已经存在Hello的字符串常量，所以直接返回该字符串常量的引用。

public static void main(String[] args) {

String a=“Hello”;

String b=“Hello”;

}

OK，学习到这里，是不是感觉自己懂了？我出一道题目来考考大家，下面这段程序的运行结果是什么？

public static void main(String[] args) {

String a =new String(new char[]{‘a’,‘b’,‘c’});

String b = a.intern();

System.out.println(a == b);

String x =new String(“def”);

String y = x.intern();

System.out.println(x == y);

}

正确答案是：

true

false

第二个输出为false还可以理解，因为new String(“def”)会做两件事：

在字符串常量池中创建一个字符串def。
new关键字创建一个实例对象string，并指向字符串常量池def的引用。

而x.intern()，是从字符串常量池获取def的引用，他们的指向地址不同，我后面的内容还会详细解释。

第一个输出结果为true是为啥捏？

JDK文档中关于intern()方法的说明：当调用intern方法时，如果常量池（内置在 JVM 中的）中已经包含相同的字符串，则返回池中的字符串。否则，将此String对象添加到池中，并返回对该String对象的引用。

在构建String a的时候，使用new char[]{‘a’,’b’,’c’}初始化字符串时（不会自动调用intern()，字符串采用懒加载方式进入到常量池），并没有在字符串常量池中构建abc这个字符串实例。所以当调用a.intern()方法时，会把该String对象添加到字符常量池中，并返回对该String对象的引用，所以a和b指向的引用地址是同一个。

问题回答

====

面试题：String a = “ab”; String b = “a” + “b”; a == b 是否相等

回答：a==b是相等的，原因如下：

变量a和b都是常量字符串，其中b这个变量，在编译时，由于不存在可变化的因素，所以编译器会直接把变量b赋值为ab（这个是属于编译器优化范畴，也就是编译之后，b会保存到Class常量池中的字面量）。
对于字符串常量，初始化a时，会在字符串常量池中创建一个字符串ab并返回该字符串常量池的引用。
对于变量b，赋值ab时，首先从字符串常量池中查找是否存在相同的字符串，如果存在，则返回该字符串引用。
因此，a和b所指向的引用是同一个，所以a==b成立。

问题总结

====

关于常量池部分的内容，要比较深入和全面的理解，还是需要花一些时间的。

比如大家通过阅读上面的内容，认为对字符串常量池有一个非常深入的理解，可以，我们再来看一个问题：

public static void main(String[] args) {

String str = new String(“Hello World”);

String str1=str.intern();

System.out.print(str == str1);

}

上面这段代码，很显然返回false，原因如下图所示。很明显str和str1所指向的引用地址不是同一个。

但是我们把上述代码改造一下：

public static void main(String[] args) {

String str = new String(“Hello World”)+new String(“!”);

String str1=str.intern();

System.out.print(str == str1);

}

上述程序输出的结果变成了：true。为什么呢？

这里也是JVM编译器层面做的优化，因为String是不可变类型，所以理论上来说，上述程序的执行逻辑是：通过+进行字符串拼接时，相当于把原有的String变量指向的字符串常量HelloWorld取出来，加上另外一个String变量指向的字符串常量!，再生成一个新的对象。

假设我们是通过for循环来对String变量进行拼接，那将会生成大量的对象，如果这些对象没有被及时回收，会造成非常大的内存浪费。

所以JVM优化之后，其实是通过StringBuilder来进行拼接，也就是只会产生一个对象实例StringBuilder，然后再通过append方法来拼接。

为了证明我说的情况，来看一下上述代码的字节码。

public static void main(java.lang.String[]);

descriptor: ([Ljava/lang/String;)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=4, locals=3, args_size=1

0: new #3 // class java/lang/StringBuilder

3: dup

4: invokespecial #4 // Method java/lang/StringBuilder.“”