• JVM 三种常量池：Class、字符串、基本类型

    本文主要讲述三种常量池： Class 常量池、字符串常量池、还有基本类型常量池。

    默认 jdk 版本：jdk 1.8

    Class 常量池

    Class 常量池可以理解为 Class 文件中的资源仓库， Class 文件中除了包含类的版本、字段、方法、接口等描述信息外，还有一项就是 常量池（constant pool table）, 用于存放编译期生成的各种 字面量（Literal）和符号引用（Symbolic References）

    我们一般会通过 javap 命令生成可读的 JVM 字节码指令文件：

    1. Classfile /Users/zhengsh/cqvie.edu.cn/ssm-salt/ssm-salt-jvm/src/main/java/cn/edu/cqvie/jvm/Math.class
    2.   Last modified 2021年2月4日; size 499 bytes
    3.   MD5 checksum 037cef02562301117a47bc10b250c770
    4.   Compiled from "Math.java"
    5. public class cn.edu.cqvie.jvm.Math
    6.   minor version: 0
    7.   major version: 52
    8.   flags: (0x0021) ACC_PUBLIC, ACC_SUPER
    9.   this_class: #2                          // cn/edu/cqvie/jvm/Math
    10.   super_class: #7                         // java/lang/Object
    11.   interfaces: 0, fields: 0, methods: 3, attributes: 1
    12. Constant pool:
    13.    #1 = Methodref          #7.#18         // java/lang/Object."":()V
    14.    #2 = Class              #19            // cn/edu/cqvie/jvm/Math
    15.    #3 = Methodref          #2.#18         // cn/edu/cqvie/jvm/Math."":()V
    16.    #4 = Fieldref           #20.#21        // java/lang/System.out:Ljava/io/PrintStream;
    17.    #5 = Methodref          #2.#22         // cn/edu/cqvie/jvm/Math.compute:()I
    18.    #6 = Methodref          #23.#24        // java/io/PrintStream.println:(I)V
    19.    #7 = Class              #25            // java/lang/Object
    20.    #8 = Utf8               <init>
    21.    #9 = Utf8               ()V
    22.   #10 = Utf8               Code
    23.   #11 = Utf8               LineNumberTable
    24.   #12 = Utf8               compute
    25.   #13 = Utf8               ()I
    26.   #14 = Utf8               main
    27.   #15 = Utf8               ([Ljava/lang/String;)V
    28.   #16 = Utf8               SourceFile
    29.   #17 = Utf8               Math.java
    30.   #18 = NameAndType        #8:#9          // "":()V
    31.   #19 = Utf8               cn/edu/cqvie/jvm/Math
    32.   #20 = Class              #26            // java/lang/System
    33.   #21 = NameAndType        #27:#28        // out:Ljava/io/PrintStream;
    34.   #22 = NameAndType        #12:#13        // compute:()I
    35.   #23 = Class              #29            // java/io/PrintStream
    36.   #24 = NameAndType        #30:#31        // println:(I)V
    37.   #25 = Utf8               java/lang/Object
    38.   #26 = Utf8               java/lang/System
    39.   #27 = Utf8               out
    40.   #28 = Utf8               Ljava/io/PrintStream;
    41.   #29 = Utf8               java/io/PrintStream
    42.   #30 = Utf8               println
    43.   #31 = Utf8               (I)V

    Constant pool: 下面的内容就是常量池，常量池中主要存放的是字面量和符号引用。

    字面量

    字面量就是指字母、数字等构成的字符串或者数值常量。

    字面量只可以以右值出现，所谓右值是指等号右边的值，如 int a = 1, 这里的 a 是左值， 1 为右值。在这个例子中 1 就是一个字面量。

    1. int a = 1;
    2. int b = 2;
    3. String str = "Hello !";

    符号引用

    符号引用是编译原理中的概念，是相对于直接引用来说的。主要包括以下三类常量

    • 类和接口的全限定名
    • 字段名称和描述符
    • 方法名称和描述符

    对于上面的 a, b 是字段名词， 就是一个符号引用，还有类似常量池中的 Ljava/io/PrintStream 是类的权限定名， main 和 compute 是方法名称，这些都是符号引用。这些常量池现在都是静态信息，只有到运行时被加载到内存后，这些符号才有对应的内存地址信息，这些常量池一旦被装入内存就变成了 运行时常量池， 对应的符号引用在程序加载或运行时就会被转变为被加载内存区的代码的直接引用，也就是我们说的动态连接了， 例如，compute() 这个符号引用在运行时就被转换成了 compute() 方法具体代码在内存中的地址，主要是通过对象头里的类型指针去转换为直接引用。

    字符串常量池

    字符串常量池的设计思想

    1. 字符串的分配，和其他的对象分配一样，耗费高昂的时间与空间代价，作为最基础的数据类型，大量频繁的常见字符串，极大程度的影响程序的性能。
    2. JVM 为了提高性能和减少开销，在实例化字符串常量的时候做了一些优化
    3. 为字符串开辟了一个字符串常量池，类似缓冲区
    4. 创建字符串常量时，首先查询字符串常量池是否存在该字符串
    5. 存在该字符串，返回引用实例，不存在，实例化该字符串并放入常量池中

    三种字符串操作（Jdk1.7 以上版本）

    • 直接赋值操作
    String a = "abc"; // 指向常量

    这个方式创建的字符串对象，只会在常量池中。

    因为有 “abc” 这个字面量，在创建的时候， JVM 会先去常量池中通过 equals(key) 方法，判断是否有相同的对象如果有，则直接返返回该对象在常量池中的引用；

    如果没有，则在常量池中创建一个新的对象，再返回引用。

    • new 创建对象
    String s1 = new String("abc"); // s1 指向内存中对象的引用

    这种方式会保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中的对象引用。

    步骤如下：

    因为有 “abc” 这个字面量，所以先回去常量池中检查字符串常量池中是否存在字符串 “abc” 。

    不存在，先在字符串常量池里创建一个字符串对象；再去内存中创建一个字符串对象 “abc”;

    如果存在的话，直接去堆内存中创建一个字符串对象 “abc”。

    最后将内存中的引用返回。

    • intern 方法
    1. String s1 = new String("abc");
    2. String s2 = s1.intern();
    3.  
    4. System.out.println(s1 == s2) //false

    String 中的 intern 方法是一个 native 的方法， 当调用 intern方法时， 如果字符串常量池已经包含一个等于此 String 对象的字符串 （用equals(object)方法确定），则返回池中的字符串。否则，将intern返回的引用指向当前字符串 s1(jdk1.6版本需要将 s1 复制到字符串常量池里)。

    字符串常量池的位置

    jdk1.6 以及版本之前，有永久代，运行时常量池在永久代，运行时常量次包含字符串常量池

    jdk1.7： 有永久代但是已经逐步 “去永久代”， 字符串常池从永久代里的运行时常量池分离到堆中

    jdk1.8 以及之后： 无永久代，运行时常量池在元空间，字符串常量池依然在堆里

    案例：

    1. /**
    2.  * VM args: -Xms10M -Xmx10M
    3.  */
    4. public class RuntimeConstantPoolOOM {
    5.  
    6.     public static void main(String[] args) {
    7.  
    8.         ArrayList<String> list = new ArrayList<>();
    9.         for (int i = 0; i < 1000000; i++) {
    10.             for (int j = 0; j < 10000000; j++) {
    11.                 list.add(String.valueOf(i + j / 1000000).intern());
    12.             }
    13.         }
    14.     }
    15. }

    运行结果：

    jdk1.7 以及以上 Exception in thread "main"
    java.lang.OutOfMemoryError: Java heap space

    jdk1.6 Exception in thread "main" java.lang.OutOfMemoryError: PermGen span

    字符串常量池设计原理

    字符串常量池底层是hotspot的C++实现的，底层类似一个 HashTable， 保存的本质上是字符串对象的引用。

    举例：

    1. String s1 = new String("he") + new String("llo");
    2. String s2 = s1.intern();
    3.  
    4. System.out.println(s1 == s2); 
    5.  
    6. // 在 JDK 1.6 下输出是 false，创建了 6 个对象；
    7. // 在 JDK 1.7 及以上的版本输出是 true，创建了 5 个对象

    为什么输出会有这些变化呢？主要还是字符串池从永久代中脱离、移入堆区的原因， intern() 方法也相应发生了变化：

    1. 在 JDK 1.6 中，调用 intern() 首先会在字符串池中寻找 equal() 相等的字符串，假如字符串存在就返回该字符串在字符串池中的引用；假如字符串不存在，虚拟机会重新在永久代上创建一个实例，将 StringTable 的一个表项指向这个新创建的实例。
    1. 在 JDK 1.7 (及以上版本)中，由于字符串池不在永久代了，intern() 做了一些修改，更方便地利用堆中的对象。字符串存在时和 JDK 1.6一样，但是字符串不存在时不再需要重新创建实例，可以直接指向堆上的实例。

    常量池案例

    常量池的几个例子

    案例 1:

    1. String s0 = "abc";
    2. String s1 = "abc";
    3. String s2 = "a" + "bc"; 
    4.  
    5. boolean b1 = s0 == s1; // true
    6. boolean b2 = s1 == s2; // true

    这两个是==的，因为在编译期间，程序会帮我们优化一次，“+”会优化掉。

    案例 2：

    String s2="sh" + new String("en");

    这种因为有new存在，也不能在编译器完成，所以在运行期间会自动给“sh”加上new String。

    1. String a = "ab";
    2. String b = "b";
    3. String c = "a" + b;
    4.  
    5. boolean b1 = a == c; // false

    这种a!=b，在字符串的"+"连接中，有字符串引用存在，而引用的值在程序编译期是无法确定的。但是底下这个是==的

    **案例 3: **

    1. String a = "ab";
    2. final String b = "b";
    3. String c = "a" + b;

    对于final修饰的变量，它在编译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码流中。

    案例 4：

    1. String a = "ab";
    2. final String b = getB();
    3. String c = "a" + b;
    4.  
    5. public static String getB(){
    6.     return "b";
    7. }

    JVM对于字符串引用b，它的值在编译期无法确定，只有在程序运行期调用方法后，将方法的返回值和"a"来动态连接并分配地址为b，故上面程序的结果为 false。

    通过以上例子我们再源码中可以找到其JVM指令码发现c的"+"操作会变成如下操作：

    1. StringBuilder temp = new StringBuilder();
    2. temp.append(a).append(b).append(c);
    3. String s = temp.toString();

    几个特殊的例子

    1. String str2 = new StringBuilder("计算机").append("技术").toString();
    2. // 因为没有出现"计算机技术"字面量，只有“计算机”、“技术”，所以不会在常量池里生成"计算机技术"，在池中没有，但是在 heap 中存在，则intern 时，会直接返回该 heap 中的引用。
    3. System.out.println(str2 == str2.intern()); // true
    4.  
    5. String str1=new StringBuilder("ja").append("va").toString(); 
    6. // 这是因为java是关键字，在JVM初始化的相关类里肯定早就放进字符串常量池了。
    7. System.out.println(str1 == str1.intern()); // false
    8.  
    9. String s1=new String("test");
    10. System.out.println(s1==s1.intern()); // true
    11.  
    12. String s2=new StringBuilder("abc").toString();
    13. // StringBuilder 的 toString 方法会 new String()，“abc”作为字面量是会放到常量池中的
    14. System.out.println(s2==s2.intern()); // false

    基本类型常量池

    java 中基本类型的包装类的大部分都实现了常量池技术(严格来说应该叫对象池，在堆上)，这些类是Byte, Short, Integer, Long, Character, Boolean, 另外两种浮点数类型的包装类则没有实现。另外 Byte, Short, Integer, Long, Character 这5种整型的包装类也只是在对应值小于等于127时才可使用对象池，也即对象不负责创建和管理大于127的这些类的对象。因为一般这种比较小的数用到的概率相对较大。

    1. //5种整形的包装类Byte,Short,Integer,Long,Character的对象，
    2. //在值小于127时可以使用对象池
    3. Integer i1 = 127; //这种调用底层实际是执行的Integer.valueOf(127)，里面用到了IntegerCache对象池
    4. Integer i2 = 127;
    5. System.out.println(i1 == i2); //输出true
    6.  
    7. //值大于127时，不会从对象池中取对象
    8. Integer i3 = 128;
    9. Integer i4 = 128;
    10. System.out.println(i3 == i4); //输出false
    11.  
    12. //用new关键词新生成对象不会使用对象池
    13. Integer i5 = new Integer(127);
    14. Integer i6 = new Integer(127);
    15. System.out.println(i5 == i6); //输出false
    16.  
    17. //Boolean类也实现了对象池技术
    18. Boolean bool1 = true;
    19. Boolean bool2 = true;
    20. System.out.println(bool1 == bool2); //输出true
    21.  
    22. //浮点类型的包装类没有实现对象池技术
    23. Double d1 = 1.0;
    24. Double d2 = 1.0;

    Integer.java 部分源码

    1. // valueOf 方法
    2. public static Integer valueOf(int i) {
    3.   if (i >= IntegerCache.low && i <= IntegerCache.high)
    4.     return IntegerCache.cache[i + (-IntegerCache.low)];
    5.   return new Integer(i);
    6. }
    7.  
    8. // IntegerCache 实现
    9. private static class IntegerCache {
    10.   static final int low = -128;
    11.   static final int high;
    12.   static final Integer cache[];
    13.  
    14.   // static 块中预先缓存 -128 ～ 127 这些数据，Long 同理 
    15.   static {
    16.     // high value may be configured by property
    17.     int h = 127;
    18.     String integerCacheHighPropValue =
    19.       sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    20.     if (integerCacheHighPropValue != null) {
    21.       try {
    22.         int i = parseInt(integerCacheHighPropValue);
    23.         i = Math.max(i, 127);
    24.         // Maximum array size is Integer.MAX_VALUE
    25.         h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
    26.       } catch( NumberFormatException nfe) {
    27.         // If the property cannot be parsed into an int, ignore it.
    28.       }
    29.     }
    30.     high = h;
    31.  
    32.     cache = new Integer[(high - low) + 1];
    33.     int j = low;
    34.     for(int k = 0; k < cache.length; k++)
    35.       cache[k] = new Integer(j++);
    36.  
    37.     // range [-128, 127] must be interned (JLS7 5.1.7)
    38.     assert IntegerCache.high >= 127;
    39.   }
    40.  
    41.   private IntegerCache() {}
    42. }

  • 相关阅读:
    Android 测试登录 adb脚本
    C++基础——函数重载
    神经网络激活函数的使用
    Selenium元素定位神器工具谷歌浏览器插件-SelectorsHub介绍、安装和使用
    Ubuntu 下51开发记录
    无代码开发关联报表入门教程
    Python库之pandas的简介、安装、使用方法详细攻略
    C++【认识继承】
    【无标题】清空吗
    【信息融合】基于matlab BP神经网络和DS证据理论不确定性信息融合问题【含Matlab源码 2112期】
  • 原文地址：https://blog.csdn.net/lt_xiaodou/article/details/126828563