请别再拿“String s = new String("xyz");创建了多少个String实例”来面试了吧

这帖是用来回复高级语言虚拟机圈子里的一个问题，一道Java笔试题的。
本来因为见得太多已经吐槽无力，但这次实在忍不住了就又爆发了一把。写得太长干脆单独开了一帖。

顺带广告：对JVM感兴趣的同学们同志们请多多支持高级语言虚拟机圈子 

以下是回复内容。文中的“楼主”是针对原问题帖而言。

===============================================================

楼主是看各种宝典了么……以后我面试人的时候就要专找宝典答案是错的来问，方便筛人orz

楼主要注意了：这题或类似的题虽然经常见，但使用这个描述方式实际上没有任何意义：

引用

问题：

String s = new String("xyz");

创建了几个String Object？

这个问题自身就没有合理的答案，楼主所引用的“标准答案”自然也就不准确了：

引用

答案：两个(一个是“xyz”,一个是指向“xyz”的引用对象s)

（好吧这个答案的吐槽点很多……大家慢慢来）

这问题的毛病是什么呢？它并没有定义“创建了”的意义。
什么叫“创建了”？什么时候创建了什么？
而且这段Java代码片段实际运行的时候真的会“创建两个String实例”么？

如果这道是面试题，那么可以当面让面试官澄清“创建了”的定义，然后再对应的回答。这种时候面试官多半会让被面试者自己解释，那就好办了，好好晒给面试官看。

如果是笔试题就没有提问要求澄清的机会了。不过会出这种题目的地方水平多半也不怎么样。说不定出题的人就是从各种宝典上把题抄来的，那就按照宝典把那不大对劲的答案写上去就能混过去了

===============================================================

先换成另一个问题来问：

引用

问题：

String s = new String("xyz");

在运行时涉及几个String实例？

一种合理的解答是：

引用

答案：两个，一个是字符串字面量"xyz"所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与"xyz"相同的实例

这是根据Java语言规范相关规定可以给出的合理答案。考虑到Java语言规范中明确指出了：

The Java Language Specification, Third Edition 写道

The Java programming language is normally compiled to the bytecoded instruction set and binary format defined in The Java Virtual Machine Specification, Second Edition (Addison-Wesley, 1999).

也就是规定了Java语言一般是编译为Java虚拟机规范所定义的Class文件，但并没有规定“一定”（must），留有不使用JVM来实现Java语言的余地。
考虑上Java虚拟机规范，确实在这段代码里涉及的常量种类为CONSTANT_String_info的字符串常量也只有"xyz"一个。CONSTANT_String_info是用来表示Java语言中String类型的常量表达式的值（包括字符串字面量）用的常量种类，只在这个层面上考虑的话，这个解答也没问题。
所以这种解答可以认为是合理的。

值得注意的是问题中“在运行时”既包括类加载阶段，也包括这个代码片段自身执行的时候。下文会再讨论这个细节与楼主原本给出的问题的关系。

碰到这种问题首先应该想到去查阅相关的规范，这里具体是Java语言规范与Java虚拟机规范，以及一些相关API的JavaDoc。很多人喜欢把“按道理说”当作口头禅，规范就是用来定义各种“道理”的——“为什么XXX是YYY的意思？”“因为规范里是这样定义的！”——无敌了。

在Java虚拟机规范中相关的定义有下面一些：

The Java Virtual Machine Specification, Second Edition 写道

2.3 Literals

A literal is the source code representation of a value of a primitive type (§2.4.1), the String type (§2.4.8), or the null type (§2.4). String literals and, more generally, strings that are the values of constant expressions are "interned" so as to share unique instances, using the method String.intern.

The null type has one value, the null reference, denoted by the literal null. The boolean type has two values, denoted by the literals true and false.

2.4.8 The Class String

Instances of class String represent sequences of Unicode characters (§2.1). A String object has a constant, unchanging value. String literals (§2.3) are references to instances of class String.

2.17.6 Creation of New Class Instances

A new class instance is explicitly created when one of the following situations occurs:

• Evaluation of a class instance creation expression creates a new instance of the class whose name appears in the expression.
• Invocation of the newInstance method of class Class creates a new instance of the class represented by the Class object for which the method was invoked.

A new class instance may be implicitly created in the following situations:

• Loading of a class or interface that contains a String literal may create a new String object (§2.4.8) to represent that literal. This may not occur if the a String object has already been created to represent a previous occurrence of that literal, or if the String.intern method has been invoked on a String object representing the same string as the literal.
• Execution of a string concatenation operator that is not part of a constant expression sometimes creates a new String object to represent the result. String concatenation operators may also create temporary wrapper objects for a value of a primitive type (§2.4.1).

Each of these situations identifies a particular constructor to be called with specified arguments (possibly none) as part of the class instance creation process.

5.1 The Runtime Constant Pool

...

● A string literal (§2.3) is derived from a CONSTANT_String_info structure (§4.4.3) in the binary representation of a class or interface. The CONSTANT_String_info structure gives the sequence of Unicode characters constituting the string literal.

● The Java programming language requires that identical string literals (that is, literals that contain the same sequence of characters) must refer to the same instance of class String. In addition, if the method String.intern is called on any string, the result is a reference to the same class instance that would be returned if that string appeared as a literal. Thus,

("a" + "b" + "c").intern() == "abc"

must have the value true.

● To derive a string literal, the Java virtual machine examines the sequence of characters given by the CONSTANT_String_info structure.

  ○ If the method String.intern has previously been called on an instance of class String containing a sequence of Unicode characters identical to that given by the CONSTANT_String_info structure, then the result of string literal derivation is a reference to that same instance of class String.

  ○ Otherwise, a new instance of class String is created containing the sequence of Unicode characters given by the CONSTANT_String_info structure; that class instance is the result of string literal derivation. Finally, the intern method of the new String instance is invoked.

...

The remaining structures in the constant_pool table of the binary representation of a class or interface, the CONSTANT_NameAndType_info (§4.4.6) and CONSTANT_Utf8_info (§4.4.7) structures are only used indirectly when deriving symbolic references to classes, interfaces, methods, and fields, and when deriving string literals.

把Sun的JDK看作参考实现（reference implementation, RI），其中String.intern()的JavaDoc为：

JavaDoc 写道

public String intern()

    Returns a canonical representation for the string object.

    A pool of strings, initially empty, is maintained privately by the class String.

    When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

    It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

    All literal strings and string-valued constant expressions are interned. String literals are defined in §3.10.5 of the Java Language Specification

    Returns:
        a string that has the same contents as this string, but is guaranteed to be from a pool of unique strings.

===============================================================

再换一个问题来问：

引用

问题：

String s = new String("xyz");

涉及用户声明的几个String类型的变量？

答案也很简单：

引用

答案：一个，就是String s。

把问题换成下面这个版本，答案也一样：

引用

问题：

String s = null;

涉及用户声明的几个String类型的变量？

Java里变量就是变量，引用类型的变量只是对某个对象实例或者null的引用，不是实例本身。声明变量的个数跟创建实例的个数没有必然关系，像是说：

String s1 = "a";
String s2 = s1.concat("");
String s3 = null;
new String(s1);

这段代码会涉及3个String类型的变量，
1、s1，指向下面String实例的1
2、s2，指向与s1相同
3、s3，值为null，不指向任何实例

以及3个String实例，
1、"a"字面量对应的驻留的字符串常量的String实例
2、""字面量对应的驻留的字符串常量的String实例
（String.concat()是个有趣的方法，当发现传入的参数是空字符串时会返回this，所以这里不会额外创建新的String实例）
3、通过new String(String)创建的新String实例；没有任何变量指向它。

===============================================================

回到楼主开头引用的问题与“标准答案”

引用

问题：

String s = new String("xyz");

创建了几个String Object？
答案：两个(一个是“xyz”,一个是指向“xyz”的引用对象s)

用归谬法论证。假定问题问的是“在执行这段代码片段时创建了几个String实例”。如果“标准答案”是正确的，那么下面的代码片段在执行时就应该创建4个String实例了：

String s1 = new String("xyz");
String s2 = new String("xyz");

马上就会有人跳出来说上下两个"xyz"字面量都是引用了同一个String对象，所以不应该是创建了4个对象。

那么应该是多少个？

运行时的类加载过程与实际执行某个代码片段，两者必须分开讨论才有那么点意义。

为了执行问题中的代码片段，其所在的类必然要先被加载，而且同一个类最多只会被加载一次（要注意对JVM来说“同一个类”并不是类的全限定名相同就足够了，而是<类全限定名, 定义类加载器>一对都相同才行）。

根据上文引用的规范的内容，符合规范的JVM实现应该在类加载的过程中创建并驻留一个String实例作为常量来对应"xyz"字面量；具体是在类加载的resolve阶段进行的。这个常量是全局共享的，只在先前尚未有内容相同的字符串驻留过的前提下才需要创建新的String实例。

等到真正执行原问题中的代码片段时，JVM需要执行的字节码类似这样：

0: new	#2; //class java/lang/String
3: dup
4: ldc	#3; //String xyz
6: invokespecial	#4; //Method java/lang/String."<init>":(Ljava/lang/String;)V
9: astore_1

这之中出现过多少次new java/lang/String就是创建了多少个String对象。也就是说原问题中的代码在每执行一次只会新创建一个String实例。
这里，ldc指令只是把先前在类加载过程中已经创建好的一个String对象（"xyz"）的一个引用压到操作数栈顶而已，并不新创建String对象。

所以刚才用于归谬的代码片段：

String s1 = new String("xyz");
String s2 = new String("xyz");

每执行一次只会新创建2个String实例。

---------------------------------------------------------------

为了避免一些同学犯糊涂，再强调一次：

在Java语言里，“new”表达式是负责创建实例的，其中会调用构造器去对实例做初始化；构造器自身的返回值类型是void，并不是“构造器返回了新创建的对象的引用”，而是new表达式的值是新创建的对象的引用。

对应的，在JVM里，“new”字节码指令只负责把实例创建出来（包括分配空间、设定类型、所有字段设置默认值等工作），并且把指向新创建对象的引用压到操作数栈顶。此时该引用还不能直接使用，处于未初始化状态（uninitialized）；如果某方法a含有代码试图通过未初始化状态的引用来调用任何实例方法，那么方法a会通不过JVM的字节码校验，从而被JVM拒绝执行。
能对未初始化状态的引用做的唯一一种事情就是通过它调用实例构造器，在Class文件层面表现为特殊初始化方法“<init>”。实际调用的指令是invokespecial，而在实际调用前要把需要的参数按顺序压到操作数栈上。在上面的字节码例子中，压参数的指令包括dup和ldc两条，分别把隐藏参数（新创建的实例的引用，对于实例构造器来说就是“this”）与显式声明的第一个实际参数（"xyz"常量的引用）压到操作数栈上。
在构造器返回之后，新创建的实例的引用就可以正常使用了。

关于构造器的讨论，可以参考我之前的一帖，实例构造器是不是静态方法？

===============================================================

以上讨论都只是针对规范所定义的Java语言与Java虚拟机而言。概念上是如此，但实际的JVM实现可以做得更优化，原问题中的代码片段有可能在实际执行的时候一个String实例也不会完整创建（没有分配空间）。

例如说，在x86、Windows Vista SP2、Sun JDK 6 update 14的fastdebug版上跑下面的测试代码：

public class C2EscapeAnalysisDemo {
  private static void warmUp() {
    IFoo[] array = new IFoo[] {
      new FooA(), new FooB(), new FooC(), new FooD()
    };
    for (int i = 0; i < 1000000; i++) {
      array[i % array.length].foo(); // megamorphic callsite to prevent inlining
    }
  }
  
  public static void main(String[] args) {
    while (true) {
      warmUp();
    }
  }
}

interface IFoo {
  void foo();
}

class FooA implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
  }
}

class FooB implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
    String s2 = new String("xyz");
  }
}

class FooC implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
    String s2 = new String("xyz");
    String s3 = new String("xyz");
  }
}

class FooD implements IFoo {
  public void foo() {
    String s1 = new String("xyz");
    String s2 = new String("xyz");
    String s3 = new String("xyz");
    String s4 = new String("xyz");
  }
}

照常用javac用默认参数编译，然后先用server模式的默认配置来跑，顺带打出GC和JIT编译日志来看

java -server -verbose:gc -XX:+PrintCompilation C2EscapeAnalysisDemo

看到的日志的开头一段如下：

  1       java.lang.String::charAt (33 bytes)
  2       java.lang.Object::<init> (1 bytes)
  3       java.lang.String::<init> (61 bytes)
  1%      C2EscapeAnalysisDemo::warmUp @ 47 (71 bytes)
  4       FooA::foo (11 bytes)
  5       FooB::foo (21 bytes)
  6       FooC::foo (31 bytes)
  7       FooD::foo (42 bytes)
[GC 3072K->168K(32768K), 0.0058325 secs]
[GC 3240K->160K(32768K), 0.0104623 secs]
[GC 3232K->160K(32768K), 0.0027323 secs]
[GC 3232K->160K(35840K), 0.0026220 secs]
[GC 6304K->160K(35840K), 0.0173733 secs]
[GC 6304K->144K(41664K), 0.0059720 secs]
[GC 12432K->144K(41664K), 0.0353320 secs]
[GC 12432K->144K(54016K), 0.0139333 secs]
  8       C2EscapeAnalysisDemo::warmUp (71 bytes)
[GC 24720K->160K(54016K), 0.0697970 secs]
[GC 24736K->160K(68800K), 0.0261921 secs]
[GC 39520K->160K(68800K), 0.0958433 secs]
[GC 39520K->160K(87168K), 0.0433377 secs]
[GC 57888K->160K(87168K), 0.0542482 secs]
[GC 57888K->148K(87168K), 0.0533140 secs]
[GC 57876K->164K(84288K), 0.0533537 secs]
[GC 55204K->164K(81728K), 0.0596820 secs]
[GC 52644K->164K(79488K), 0.0515090 secs]
[GC 50212K->164K(76992K), 0.0491227 secs]
[GC 47908K->164K(74944K), 0.0450666 secs]
[GC 45668K->164K(72640K), 0.0467671 secs]
[GC 43556K->152K(70784K), 0.0420757 secs]
[GC 41560K->168K(68736K), 0.0391296 secs]
[GC 39656K->168K(67072K), 0.0397539 secs]
[GC 37864K->188K(65216K), 0.0360861 secs]

上面的日志中，后面的方法名的行是JIT编译的日志，而以[GC开头的是minor GC的日志。
程序一直跑，GC的日志还会不断的打出来。这是理所当然的对吧？HotSpot的堆就那么大，而测试代码在不断新创建String对象，肯定得不断触发GC的。

用不同的VM启动参数来跑的话，

java -server -verbose:gc -XX:+PrintCompilation -XX:+DoEscapeAnalysis -XX:+EliminateAllocations C2EscapeAnalysisDemo

还是同样的Java测试程序，同样的Sun JDK 6 update 14，但打开了逃逸分析和空间分配消除功能，再运行，看到的全部日志如下：

  1       java.lang.String::charAt (33 bytes)
  2       java.lang.Object::<init> (1 bytes)
  3       java.lang.String::<init> (61 bytes)
  1%      C2EscapeAnalysisDemo::warmUp @ 47 (71 bytes)
  5       FooB::foo (21 bytes)
  4       FooA::foo (11 bytes)
  6       FooC::foo (31 bytes)
  7       FooD::foo (42 bytes)
[GC 3072K->176K(32768K), 0.0056527 secs]
  8       C2EscapeAnalysisDemo::warmUp (71 bytes)

继续跑下去也没有再打出GC日志了。难道新创建String对象都不吃内存了么？

实际情况是：经过HotSpot的server模式编译器的优化后，FooA、FooB、FooC、FooD四个版本的foo()实现都不新创建String实例了。这样自然不吃内存，也就不再触发GC了。
经过的分析和优化笼统说有方法内联（method inlining）、逃逸分析（escape analysis）、标量替换（scalar replacement）、无用代码削除（dead-code elimination）之类。

FooA.foo()最短，就以它举例来大致演示一下优化的过程。
它其实就是创建并初始化了一个String对象而已。调用的构造器的源码是：

public String(String original) {
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // The array representing the String is bigger than the new
       // String itself.  Perhaps this constructor is being called
       // in order to trim the baggage, so make a copy of the array.
      int off = original.offset;
      v = Arrays.copyOfRange(originalValue, off, off+size);
    } else {
       // The array representing the String is the same
       // size as the String, so no point in making a copy.
      v = originalValue;
    }
    this.offset = 0;
    this.count = size;
    this.value = v;
}

因为参数是"xyz"，可以确定在我们的测试代码里不会走到构造器的if分支里，下面为了演示方便就省略掉那部分代码（实际代码还是存在的，只是没执行而已）

public String(String original) {
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }
    this.offset = 0;
    this.count = size;
    this.value = v;
}

那么把构造器内联到FooA.foo()里，

public FooA implements IFoo {
  public void foo() {
    String s = AllocateString(); // 这里虚构一个只分配空间，不调用构造器的函数
    String original = "xyz";

    // 下面就是内联进来的构造器内容
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }

    s.offset = 0;
    s.count = size;
    s.value = v;
  }
}

然后经过逃逸分析与标量替换，

public FooA implements IFoo {
  public void foo() {
    String original = "xyz";
    
    // 下面就是内联进来的构造器内容
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }
    
    // 原本s的实例变量被标量替换为foo()的局部变量
    int sOffset = 0;
    int sCount = size;
    char[] sValue = v;
  }
}

注意，到这里就已经把新创建String在堆上分配空间的代码全部削除了，原本新建的String实例的字段变成了FooA.foo()的局部变量。
最后再经过无用代码削除，把sOffset、sCount和sValue这三个没被读过的局部变量给削除掉，

public FooA implements IFoo {
  public void foo() {
    String original = "xyz";
    
    // 下面就是内联进来的构造器内容
    int size = original.count;
    char[] originalValue = original.value;
    char[] v;
    if (originalValue.length > size) {
       // 省略
    } else {
      v = originalValue;
    }
    
    // 几个局部变量也干掉了
  }
}

这就跟FooA.foo()被优化编译后实际执行的代码基本一致了。
实际执行的x86代码如下：

0x0247aeec: mov    %eax,-0x4000(%esp) ; 检查栈是否溢出（stack bang），若溢出则这条指令会引发异常
0x0247aef3: push   %ebp               ; 保存老的栈帧指针
0x0247aef4: sub    $0x18,%esp         ; 为新栈帧分配空间
0x0247aefa: mov    $0x1027e9a8,%edi   ; String original /* EDI */ = "xyz"
0x0247aeff: mov    0x8(%edi),%ecx     ; char[] originalValue /* ECX */ = original.value;
0x0247af02: mov    0x8(%ecx),%ebx     ; EBX = originalValue.length
0x0247af05: mov    0x10(%edi),%ebp    ; int size /* EBP */ = original.count;
0x0247af08: cmp    %ebp,%ebx          ; 比较originalValue.length与size
0x0247af0a: jg     0x0247af17         ; 如果originalValue.length > size则跳转到0x0247af17
                                      ;   实际不会发生跳转（就是不会执行if分支），所以后面代码省略
0x0247af0c: add    $0x18,%esp         ; 撤销栈帧分配的空间
0x0247af0f: pop    %ebp               ; 恢复老的栈帧指针
0x0247af10: test   %eax,0x310000      ; 方法返回前检查是否需要进入safepoint （{poll_return}）
0x0247af16: ret                       ; 方法返回
0x0247af17: ; 以下是if分支和异常处理器的代码，因为实际不会执行，省略

看，确实没有新创建String对象了。

另外三个版本的foo()实现也是类似，HotSpot成功的把无用的new String("xyz")全部干掉了。
关于逃逸分析的例子，可以参考我以前一篇帖，HotSpot 17.0-b12的逃逸分析/标量替换的一个演示

再回头看看楼主的原问题，问题中的代码片段执行的时候（对应到FooA.foo()被调用的时候）一个String对象也没有新建。于是那“标准答案”在现实中的指导意义又有多少呢？

===============================================================

另外，楼主还提到了PermGen：

QM42977 写道

"xyz"在perm gen应该还会生成一个对象，因为常量("xyz")都会保存在perm gen中

这里也是需要强调一点：永生代（“Perm Gen”）只是Sun JDK的一个实现细节而已，Java语言规范和Java虚拟机规范都没有规定必须有“Permanent Generation”这么一块空间，甚至没规定要用什么GC算法——不用分代式GC算法哪儿来的“永生代”？

HotSpot的PermGen是用来实现Java虚拟机规范中的“方法区”（method area）的。如果使用“方法区”这个术语，在讨论概念中的JVM时就安全得多——大家都必须实现出这个表象。
当然如何实现又是另一回事了。Oracle JRockit没有PermGen，IBM J9也没有，事实上有这么一块空间特别管理的反而是少数吧orz

事实上新版HotSpot VM也在计划去除PermGen，转而使用native memory来实现方法区存储元数据。在JDK8的HotSpot VM中已经实现了这点。
可以参考这帖：http://rednaxelafx.iteye.com/blog/905273

===============================================================

费那么多口舌，最后点题：请别再拿“String s = new String("xyz");创建了多少个String实例”来面试了吧，既没意义又不涨面子。

困，睡觉去……

评论

119 楼 DovahYol 2018-03-10  

RednaxelaFX 写道

AnonymMan 写道

http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html 看完你就懂了。

嗯这篇写得不错的

然而根据http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html
的话，

引用

答案：两个，一个是字符串字面量"xyz"所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与"xyz"相同的实例

是错误的。

因为是new出来的对象，对象只会存在于堆中，并不会intern在字符串常量池中。而且要intern的话，是堆中对象的引用，而不是堆中对象本身。

118 楼 ouym337 2015-09-09  

感谢大神细致的讲解，已关注。
不过我有一个问题不知道对不对

-------------------------------------------------------------
String s = new String("xyz"); 
在运行时涉及几个String实例？

一种合理的解答是：
引用
答案：两个，一个是字符串字面量"xyz"所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，另一个是通过new String(String)创建并初始化的、内容与"xyz"相同的实例
--------------------------------------------------------------

驻留（intern）在一个全局共享的字符串常量池中的实例，这里在jdk1.6以及以前会将字符串实例复制到永久代中，jdk1.7后改为复制实例的引用。

117 楼 RednaxelaFX 2014-11-18  

AnonymMan 写道

http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html 看完你就懂了。

嗯这篇写得不错的

116 楼 AnonymMan 2014-11-17  

http://www.javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html 看完你就懂了。

115 楼 working_brain 2014-05-20  

大神，我想确定下，String str=new String("ab");执行完成后，这个ab的值或者引用在不在string pool中呢？还是执行玩intern之后才会有？

114 楼 kaiyuanjava 2013-07-31  

您好哦，其他文章我也都看过了，其中应该如下这篇文章问题看的比较久，
也产生了一些疑问，希望赐教！
http://hllvm.group.iteye.com/group/topic/26412

引用

HotSpot VM用instanceKlass来记录类的元数据，每个Java类有一个对应的instanceKlass。
每个instanceKlass上引用着一个constantPoolOopDesc对象，然后间接引用着一个constantPoolCacheOopDesc对象。
前者跟Class文件里记录的常

量池的结构类似，而后者是为了让解释器运行得更高效的一个缓存。

此处已经说明每个类会存在一个instanceKlass

引用

举例：java.lang.String对应的一个instanceKlass,
留意到instanceKlass里有个_constants字段，引用着一个constantPoolOopDesc对象（后面简称constantPool对象）。
观察constantPool对象的内容：留意到它是一个类似数组的对象，里面有_length字段描述常量池内容的个数，后面就是常量池项了。
通过观察其中一个symbol对象（内容是"intern"),它的结构跟数组类似，有_length来记录长度，后面是UTF-8编码的字节。

从以上两段文字能说明运行时某个类中的instanceKlass中的constantPool代表着运行时常量池

而后面提到：

引用

instanceKlass中的constantPool 中的JVM_CONSTANT_Methodref: 26738818
其中 JVM_CONSTANT_Methodref: 26738818 =  408 << 16 | 130
和 （在javap中的可见） 常量 #130.#408 相等
观察constantPool对象的内容：留意到它是一个类似数组的对象，里面有_length字段描述常量池内容的个数，后面就是常量池项了。
各个类型的常量是混在一起放在常量池里的，跟Class文件里的基本上一样。
最不同的是在这个运行时常量池里，symbol是在类之间共享的；而在Class文件的常量池里每个Class文件都有自己的一份symbol内容，没共享。

这句比较关键，看的不太懂

所以综上自己得出结论，运行时常量池是所有类共享
我也产生新的疑问如下：
1、运行时常量池是所有类共享的，
   那么是每个类有自己的运行时常量池，然后对整个VM可见实现共享，
   还是运行时常量池只有一份，所有类引用的instanceKlass引用了这份Copy?
2、Class文件中的常量的独有的symbol是指哪个？
   是如文章中图一所见的instanceKlass吗？
   还是只是通过javap 看到的
3、通过javap看到的常量池我的理解是类文件结构的一部分，在不人为改变情况下，VM会去改变这个头常量池结构吗？
望赐教，
SA插件我在本机上安装不，看楼主的是VISUALVM1.3 而我的没版本，不知道有关系没有。

113 楼 RednaxelaFX 2013-07-30  

kaiyuanjava 写道

每个类有自己的方法区，每个类初始化后，在方法区的位置（地址）一定是不同的。
而且他们各自有各自的常量池，那么当比较这两个常量池字符串时，如何比较，

您误解的地方就在此。类的运行时常量池（runtime constant pool）与JVM的全局字符串池（string pool）不是一回事。对JVM不够了解的人总说“常量池”“常量池”，很容易把实际不一样的东西混为一谈。看这帖楼主在问问题的时候也是没指定清楚。

每个类在运行时都有自己的一个独立的运行时常量池，里面的内容跟Class文件里的常量池对应。样子像这样：http://hllvm.group.iteye.com/group/topic/26412

而用来存驻留字符串（interned string）的全局字符串池（string pool）才是您想问的东西。您可以自己试试参考这帖的方式动手探索一下string pool的内容；HotSpot VM里实现string pool功能的是StringTable类，在hotspot/src/share/vm/classfile/symbolTable.[hpp|cpp]。

简单来说，HotSpot VM里StringTable是个哈希表，里面存的是驻留字符串的引用（而不是驻留字符串实例自身）。也就是说某些普通的字符串实例被这个StringTable引用之后就等同被赋予了“驻留字符串”的身份。这个StringTable在每个HotSpot VM的实例里只有一份，被所有的类共享。类的运行时常量池里的CONSTANT_String类型的常量，经过解析（resolve）之后，同样存的是字符串的引用；解析的过程会去查询StringTable，以保证运行时常量池所引用的字符串与StringTable所引用的是一致的。

顺带一提，这两帖楼主也可以参考一下：
http://www.iteye.com/topic/1112592?page=3#2216483
http://hllvm.group.iteye.com/group/topic/37682

112 楼 kaiyuanjava 2013-07-30  

先称呼声“大牛牛”，分析的很透彻，我理解的层次在这里，
您的文章我已经看过了，讲解的很明白，
不过我还有个疑问就是
就是在不用逃逸分析，不用标量替换，不用无用代码消除的情况下.
每个类有自己的方法区，每个类初始化后，在方法区的位置（地址）一定是不同的。
而且他们各自有各自的常量池，那么当比较这两个常量池字符串时，如何比较，
例如：
假设有两个类：A 和 B ，其中A中有成员变量 aabc = "abc" , B类中有成员变量
babc , 那么 他们分别有自己的
方法区的
如下类：
Class A{
   private String aabc = "abc";

   public String getAbcString(){
      return this.aabc;
   }

}
Class B{
   private String babc = "abc";
   public String getAbcString(){
      return this.babc;
   }
}
new A().getAbcString() 与 new B().getAbcString()
是否相等,我测试的结果是相等。
但是不理解的是：
因为String 是引用类型，那么指向的要么是堆中的地址
要么是常量池中的常量，
A 和 B 类加载后分别位于常量池不同的地址，
那String虽然值相等，但是两个字符串却位于不同类的不同的常量池表，为什么A 和 B 类 的字符串还相等还相等。

111 楼 shenqioa 2013-04-11  

是一篇老帖子了 从中学习到不少东西 很认同RednaxelaFX的精神 细致认真 让具有一般水平的人也能够看得懂 同时旁征博引 。本来是想从评论当中也发现点其他的信息但看到下面这条狗的犬吠-->  allskylove   让我很是鄙视，除了扰乱和打击他人 我并未看到他水平上比楼主高多少，至于素质和修养更是云泥之别！

110 楼 zzf8845 2012-12-05  

public static void main(String[] args) {
String sQuotation0 = "s";
String sQuotation1 = "s";
String sNew0 = new String("s");
String sNew1 = new String("s");

if (sQuotation0 == sQuotation1) {
System.out.println("quotation is " + true);
}

if (sNew0 == sNew1) {
System.out.println("new is " + true);
}
if (sQuotation0 == sNew0) {
System.out.println("quotation is " + true + " new");
}
}


quotation is true

109 楼 CreasyOoh 2012-10-26  

很专业 期望慢慢学习 达到楼主的水平 长见识了

108 楼 S.t.Goh 2012-06-16  

学习了~~~

107 楼 清水幽香 2011-06-27  

刚才我也看到一个宝典上有这么一道题，就看了看!然后看到LZ这么激情洋溢的描述果然是被雷到了！嗨！看来还是要潜心研究啊！话不多说，言归正传！

有人回答是这样的:

引用

两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

两个情况的就不用说了，LZ说的很清楚了！可是一个呢？
如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿，甚么叫以前就用过‘xyz’,这句话是甚么意思？能不能举个例子呢？说清楚点！最好能对比String s = new String("xyz")这个！

106 楼 kanny87929 2011-06-04  

想不到这个问题扯这么久

105 楼 RednaxelaFX 2011-06-04  

takingoff 写道

关键是 这个问题实际应用中  有什么地方开发必须要深究这个地方？

我想说的不就是这个么…既然许多职位不需要在这种问题上纠结，最初就不应该在面试的时候问这种问题。

104 楼 takingoff 2011-06-04  

关键是 这个问题实际应用中  有什么地方开发必须要深究这个地方？

103 楼 MrScott 2011-04-29  

面试大唐电信的时候，出了这么一道

 
String s = new String("hello")// 创建了几个String object对象

当时直接没想，就填了两个。呵呵。学习了。

102 楼 tangay 2011-04-25  

pouyang 写道

String s = new String("b"+"c");

在运行时涉及几个String实例?

应该是2个，常量池里面是“bc”，堆里面是有个new出来的，这里编译器会把“b”+"c"优化成“bc”的

101 楼 weng 2011-04-25  

gorymt 写道

感谢这么细致的讲解，学到很多
貌似五点多发的贴，楼主辛苦了~

引用

楼主是看各种宝典了么……以后我面试人的时候就要专找宝典答案是错的来问，方便筛人orz

原来看了半天的宝典好多错，还有人专门用来出题。。。我表示鸭梨很大…………

同感

100 楼 RednaxelaFX 2011-04-23  

呃，又被挖起来了么

sky_dream 写道

鸭梨很大，冒昧问下楼主几年了，给大家推荐一下书籍，感觉很多底层需要好好学习。

现在的话毕业1年多了，嗯。不过平时如果只是做纯Java层的开发的话不需要知道那么深的完全没关系。或者说，知道的比需要的多但却又不够多的话反而更危险，呃呵呵。

虽然顶楼开头就提到了，想再说一次，写这篇是为了说明这个问题缺乏实际意义所以没必要在面试里问。That's the only takeaway here.