你好，Intern()

2017-11-12 本文已影响20人做梦枯岛醒

1.序

我醒来，在一个陌生的世界。
周围没有一个熟悉的人，这里一望无尽，身前身后都是空寂。

走着，碰见一群可爱的小家伙们，有个大家伙似乎控制着它们，他们完全听从他的指挥。

我上前去询问，你们是什么？
“常量！”

常量代表程序运行过程中不能改变的值，一般使用final修饰。
在Java中常量可以先声明，然后进行赋值，但是只能赋值一次。

我恍然，
“那这里是JVM的常量池吧？”

常量池是为了避免频繁的创建和销毁对象而影响系统性能而建立的存放常量的空间，其实现了对象的共享。比如字符串常量池（下面所用的），整形常量池

“对呀，这里是运行时常量池！”。

所谓运行时常量池，则是jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池（java6）,运行时常量池不是一成不变的，比如使用intern()就可以把新的内容放到常量池。

我顺着光走过去，遇到了一个检察员，他正在忙碌的寻找着，找到了就带着小家伙的标记出去，找不到就做一个小家伙放在池子里。

“初次见面，请多关照！”，我走上前去打招呼
“你叫什么？”

“我……"；

突然，小家伙们吵起来，又有新的伙伴进来了，可是小小的池子里已经塞满了小常量，根本就塞不下啦。

随着一声巨响，梦境破碎了。
我醒来。
我打开IDEA。

2.码

写下来这样一段代码

         String str0 = "a";
         String str1 = "a";
         String str2 = "b";
         String str3 = "ab";
         String str6 = "a"+"b";
         String str4 = str1 + str2;
         String str5 = new String("ab");

         /**
         * 这个返回true，因为字符串被写死，在编译期间直接放入常量池从而实现复用，
         * 那么这样看来，s0和s1指向同一个内存地址，所以相等
         * */
         System.out.println(str0 == str1);  //true
         /**
         * s6是使用+符号动态拼接出来的字符串，但是参与拼接的也是很显然的字面量（写出内容的），所以
         * 在编译期间，编译器会直接拼接，从而实现复用，那么在常量池中，达到的效果和上面的效果一样
         * */
         System.out.println(str3 == str6);  //true
         /**
         * s4的拼接在人为看来同s6没有什么两样，最后达到的效果也是一样的，那么这样就可以解释
         * s4.equal(s3)了，那么s4 为什么 == s3 ，这个是要看JVM的操作了，
          * JVM会先创建一个StringBuilder对象，通过StringBuilder.append()
          * 方法将s1与s2的值拼接，然后通过StringBuilder.toString()
          * 返回一个String对象，赋值给str4，因此str1和str5指向的不是同一个
          * String对象，str4 == str3不成立；
         * */
         System.out.println(str4 == str3);  //false
         System.out.println(str4.equals(str3));  //ture
         /**
          * 很显然，内容一致equal一定成立，但是s5是新建对象，那么一定不等于s3
          * */
         System.out.println(str5.equals(str3));  //true
         System.out.println(str5 == str3);   //false

首先写下的是一些很常见的比较，具体为什么有这样的执行结果大家都已经很明了，不懂的可以参考注释。

恍过神，记起来那个检查员。
查阅资料。

寻找，寻找。
我想它应该是intern()吧。

3.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
* <cite>The Java™ Language Specification</cite>.
* @return a string that has the same contents as this string, but is
* guaranteed to be from a pool of unique strings.
*/

Q1:什么是intern()?

正如上面官方给的解释，如果一个string调用了intern(),如果字符串常量池中已经包含等于此String的字符串，则从常量池将字符串引用返回，否则将此字符串对象添加到常量池，并且返回String对象的引用，当且仅当s.equals(t)的时候，s.intern() = t.intern()返回true。
String.intern()是一个Native方法，底层调用C++的 StringTable::intern方法实现。

那么我们来试一试；

         String a = "a";
         String b = "a";
         System.out.println(a.intern() == b.intern()); //true

返回为ture，这也是上面所说的当且仅当s.equals(t)的时候，s.intern() = t.intern()返回true。

Q2：intern()的前生今世

Java6/HotSpot1.6：

注:下文所提到的永久代与方法区不等价，但在Hotspot开发中，大家习惯把方法区称为永久代

本版本中常量池存在于永久代（PermGen）中，永久代和Java堆的内存是物理隔离的，Java6中intern()方法会把首次遇到的字符串实例复制到PermGen，执行intern方法时，如果常量池不存在该字符串，虚拟机会在常量池中复制该字符串，并返回引用，如果存在则直接返回引用，但是正是因为常量池在永久代里，导致出现了几个问题

问题1.

永久代是一块大小固定的区域，不同平台的永久代默认大小也不同，大致在32M与96M之间，所以当对象内容不可控时(比如人为输入，系统生成等)，很有可能发生PermGenOOM

问题2.

String对象保存在Java堆，而此时的Java堆和永久代是属于虚拟机中两部分的，因此如果对不等值的字符串对象进行intern操作，那么永久代就会出现内存浪费。

6.png

Java7/HotSpot1.7：

常量池在java堆上分配内存，执行intern方法时，如果常量池已经存在相等的字符串，则直接返回字符串引用，否则复制该字符串引用到常量池中并返回；intern()会进行一个引用保存的操作而不是对象复制，将在下面提到，相比与永久代，堆区的好处如下：
1.堆区大小不受限制，那么常量池也随之不受内存限制，同时GC可以一并回收常量池的垃圾。
2.相比于永久代，堆中常量池对于字符对象的利用更充分，不会因为调用了intern()就产生很多版本复制。

7.png

正是迁移常量池的这个做法，解决了Java6的缺点。

那么下面的这个小例子可以说明这个问题。

源码参考：http://www.jianshu.com/p/c14364f72b7e，同时这也是《深入理解Java虚拟机》一书给的例子，在原来基础上稍作修改

        String s0 = "java";
        String s1 = new StringBuilder("String").append("Test").toString();
        System.out.println(s1.intern() == s1);
        String s2 = new StringBuilder("ja").append("va").toString();
        System.out.println(s2.intern() == s2);

Java6的输出结果是false false
如图所示，

Java6.png

代码第一句，首先写了一个字面上的量（就是直接写了”xxxx“字符串），这样写JVM会直接将其放入常量池，此时常量池有“java”。
代码第二句生成了堆中的StringTest，并且s1是堆中对象的引用，或者说s1指向的是堆中对象，
第三句输出，s1.intern（）会去永久代里的常量池检查，没有StringTest之后，将StringTest加入其中，并且返回其引用，我们可以这样理解，s1.intern()指向了常量池，按照我们所说的，由于永久代和堆区的物理隔离，这两个地址显然不同，这样显然是s1.inrern() != s1的。
同理第四句，虽然常量池在这之前包括“java”，但是也只是让intern()找到了它，返回的引用也是在永久代中，不可能会与堆中地址相等。

我们可以看到，这样子的永久代会产生很多对象副本，如果超过了永久代储存能力就会发生OOM，很不安全。

Java7的结果是true false
如图所示

Java7

同样，代码第一句，JVM会直接将其放入常量池，此时常量池有“java”。
代码第二句生成了StringTest对象，s1指向它。
第三句，s1.intern()去常量池寻找这个字符串，在常量池中没有找到StringTest，但是不生成一个对象复制，而只是在常量池中记录下首次出现的实例地址，也就是堆区中StringTest所在的位置，此时s1.intern()与s1同时指向堆中StringTest对象，那必定返回true
第四句，堆中有了一个内容为Java的字符串对象，并且s2指向它，但是s2.intern()找到了一个常量池存在的“Java”，所以指向了它，那么我们可以通过图片看到，s2.intern()与s2不相等。

堆中放置常量池提供了很大的空间，并且大大减少了对象的重复生成。

同样，我们做另一个小实验

          String s1 = new StringBuilder("String").append("Test").toString();
        System.out.println(s1.intern() == s1);
        String s2 = new StringBuilder("ja").append("va").toString();
        System.out.println(s2.intern() == s2);

这样子就会返回true ture了。因为图中的“java”部分不存在了。

        String s1 = new StringBuilder("String").append("Test").toString();
        System.out.println(s1.intern() == s1);
        String s2 = new StringBuilder().append("StringTest").toString();
        System.out.println(s2.intern() == s2);

这样子由于s1建立时常量区没有StringTest，当s2建立的时候常量区已经有了，并且是s1那时候建立的，必定不能和新建立的这个地址一样，所以上述代码返回true false

        String s1 = new StringBuilder("123").append("45").toString();
        System.out.println(s1.intern() == s1);
        String s2 = new StringBuilder("12").append("3").toString();
        System.out.println(s2.intern() == s2);
        String s3 = new StringBuilder("45").toString();
        System.out.println(s3.intern() == s3);

这段代码输出：true false false ，大家可以思考一下为什么。

Q3：intern()用来干什么？

我们已经明白了intern()的大致用法，那么intern()能给我们带来什么好处？

首先我们要知道intern()其实是可以代替 == 或者 equal的，效率比较快，内存占用较少。

public static void main(String[] args) {
        print("noIntern: " + noIntern());
        print("intern: " + intern());
    }

    private static long noIntern(){
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            int j = i % 100;
            String str = String.valueOf(j);
        }
        return System.currentTimeMillis() - start;
    }

    private static long intern(){
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            int j = i % 100;
            String str = String.valueOf(j).intern();
        }
        return System.currentTimeMillis() - start;
    }

作者：LilacZiyun
链接：http://www.jianshu.com/p/95f516cb75ef
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

//Output:
noIntern: 48    // 未使用intern方法时，存储100万个String所需时间
intern: 99      // 使用intern方法时，存储100万个String所需时间

这段代码来自于LilacZiyun.
那么我们可以明白intern其实不是用来代替equal或者==，也不是随手就用的，主要是用于存在大量相同数据或者反复使用的情况。

4.终

2017-11-12 00:03:17，该睡觉了。

去梦里，见见那些孩子们吧。

如能有幸，我带更多那个世界的秘密来，好么？

晚安，孤独的创作者。