字符串常量池存储在堆内存空间中,创建形式如下图所示。
当使用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.“”😦)V
7: new #5 // class java/lang/String
10: dup
11: ldc #6 // String Hello World
13: invokespecial #7 // Method java/lang/String.“”:(Ljava/lang/String;)V
16: invokevirtual #8 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: new #5 // class java/lang/String
22: dup
23: ldc #9 // String !
25: invokespecial #7 // Method java/lang/String.“”:(Ljava/lang/String;)V
28: invokevirtual #8 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31: invokevirtual #10 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
34: astore_1
35: aload_1
36: invokevirtual #11 // Method java/lang/String.intern:()Ljava/lang/String;
39: astore_2
40: getstatic #12 // Field java/lang/System.out:Ljava/io/PrintStream;
43: aload_1
44: aload_2
45: if_acmpne 52
48: iconst_1
49: goto 53
52: iconst_0
53: invokevirtual #13 // Method java/io/PrintStream.print:(Z)V
56: return
从字节码中可以看到,构建了一个StringBuilder,
0: new #3 // class java/lang/StringBuilder
然后把字符串常量通过append
方法进行拼接,最后调用toString()
方法得到一个字符串常量。
16: invokevirtual #8 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
28: invokevirtual #8 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31: invokevirtual #10 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;