《性能调优之JVM》❤️04JVM常量池详解之深入理解Class常量池、运行时常量池、字符串常量池、八种基本数据类型的包装类和对象池

❤️作者主页： 温文尔雅的清欢渡
❤️ 近期学习方向： 性能调优

❤️欢迎 点赞 👍 收藏 ⭐ 留言 📝 关注 ✌ 私聊我

一、Class常量池

Class常量池就像Class文件中的资源仓库。包含类的版本、字段、方法、接口等描述信息， 以及常量池。常量池用于存放编译期生成的各种字面量和符号引用等信息。

       int a = 1;
       String b = "boss";

简单的讲，等号的左边就是符合引用，等号的右边就是字面量。

1.1字面量

字面量指的是由字母、数字等构成的字符串或者数值常量。
字面量只可以右值出现，所谓右值是指等号右边的值，如：int a=1 这里的a为左值，1为右值。在这个例子中1就是字面量。

1.2符号引用

符号引用是编译原理中的概念，是相对于直接引用来说的。主要包括了以下三类常量：
1.类和接口的全限定名 ，比如Stud类常量池里的 com/stud是类的全限定名
2.字段的名称和描述符 ， 比如a，b就是字段名称，就是一种符号引用
3.方法的名称和描述符 ，比如main和add是方法名称，()是一种UTF8格式的描述符

这些常量池现在是静态信息，只有到运行时被加载到内存后，这些符号才有对应的内存地址信息，这些常量池一旦被装入内存就变成运行时常量池，对应的符号引用在程序加载或运行时会被转变为被加载到内存区域的代码的直接引用，也就是我们说的动态链接了。
例如，add()这个符号引用在运行时就会被转变为add()方法具体代码在内存中的地址，主要通过对象头里的类型指针去转换直接引用。

二、运行时常量池

运行时常量池指的是符号引用在运行时被加载到内存的常量池。

三、字符串常量池

3.1设计思想

1. 字符串的分配，和其他的对象分配一样，耗费高昂的时间与空间代价，作为最基础的数据类型，大量频繁的创建字符串，极大程度地影响程序的性能
2. JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化：

为字符串开辟一个字符串常量池，类似于缓存区。
当创建字符串常量时，首先查询字符串常量池是否存在该字符串 ，
存在该字符串，返回引用实例；
不存在，实例化该字符串并放入池中。

3.2设计原理

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

3.3字符串常量池位置

Jdk1.6及之前： 有永久代, 运行时常量池在永久代，运行时常量池包含字符串常量池
Jdk1.7：有永久代，字符串常量池从永久代里的运行时常量池分离到堆里
Jdk1.8及之后： 无永久代，运行时常量池在元空间，字符串常量池里依然在堆里

3.４三种字符串操作

(1)直接赋值字符串

 String phone = "xiaomi10"; // phone 指向常量池中的引用

这种方式创建的字符串对象，只会在常量池中。
因为有"xiaomi10"这个字面量，创建对象phone 的时候，JVM会先去常量池中通过equals(oject) 方法，判断是否有相同的对象
如果有，则直接返回该对象在常量池中的引用；
如果没有，则会在常量池中创建一个新对象，再返回引用。

(2)new String();

 String phone = new String("xiaomi10"); // phone 指向堆内存中的对象引用

这种方式会保证字符串常量池和堆中都有这个对象，没有就创建，最后返回堆内存中的对象引用。
步骤大致如下： 因为有"xiaomi10"这个字面量，所以会先检查字符串常量池中是否存在字符串"xiaomi10"
不存在，先在字符串常量池里创建一个字符串对象；再去内存中创建一个字符串对象"xiaomi10"；
存在的话，就直接去堆内存中创建一个字符串对象"xiaomi10"；
最后，将堆内存中的引用返回。

(3)intern();

  String phone1 = new String("xiaomi10");
  String phone2 = phone1.intern();
  System.out.println(phone1 == phone2); //false

String中的intern方法是一个 native 的方法，当调用 intern方法时，
如果池已经包含一个等于此String对象的字符串 （用equals(oject)方法确定），则返回池中的字符串。
否则，将intern返回的引用指向当前字符串 s1。

四、八种基本数据类型的包装类和对象池

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

   public static void main(String[] args) {
        Integer i1 = 127; //这种调用底层实际是执行的Integer.valueOf(127)，里面用到了IntegerCache对象池
        Integer i2 = 127;
        System.out.println(i1 == i2);//输出true

        //值大于127时，不会从对象池中取对象
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3 == i4);//输出false

        //用new关键词新生成对象不会使用对象池
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(127);
        System.out.println(i5 == i6);//输出false

        //Boolean类也实现了对象池技术,存放了"true"
        Boolean bool1 = true;
        Boolean bool2 = true;
        System.out.println(bool1 == bool2);//输出true

        //浮点类型的包装类没有实现对象池技术
        Double d1 = 1.0;
        Double d2 = 1.0;
        System.out.println(d1 == d2);//输出false
    }

Integer.valueOf()源码

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];//在范围内就直接从对象池里面拿对象
        return new Integer(i);//否则,new一个新对象
    }

//下面的代码是Integer的对象池IntegerCache
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++);//new256个对象,放到对象池

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }