一、基本案例

1、new String("helloworld") 与 "helloworld"

public static void main(String[] args) throws Exception {

        String s0 = new String("helloworld");

        String s1 = s0.intern(); // 此时"helloworld"已经存在常量池中，现在只是通过intern方法取出而已

        String s2 = "helloworld"; //

        System.out.println(s0 == s1); // false

        System.out.println(s2 == s1); // true

}

// 学过java编译过程的都知道编译会进行热点代码的优化，如：方法内联、常量传播、空值检查消除、寄存器分配等等，热点代码一般通过热点探测得出，而HotSpotIntrinsicCandidate注解能够直接手段将某个方法直接指定为热点代码，jvm尽快优化它（非绝对优化，优化时机不确定）。

// 注释简言之：new String("helloworld") 是"helloworld"的一个复制；因为String是不可变的，除非需要显示复制"hellworld"，不然使用构造器来复制字符串是不必要的。

/**

* Initializes a newly created {@code String} object so that it represents

* the same sequence of characters as the argument; in other words, the

* newly created string is a copy of the argument string. Unless an

* explicit copy of {@code original} is needed, use of this constructor is

* unnecessary since Strings are immutable.

*

* @param  original

*         A {@code String}

*/

@HotSpotIntrinsicCandidate

public String(String original) {

    this.value = original.value;

    this.coder = original.coder;

    this.hash = original.hash;

}

（1）对比new String("helloworld")与"helloworld"的反编译源码

// 对应的反编译源码

public static void main(java.lang.String[]) throws java.lang.Exception;

    Code:

	   // new 创建一个对象，并将其引用值压入栈顶

       0: new           #2                  // class java/lang/String

       // 复制栈顶数值(数值不能是long或double类型的)并将复制值压入栈顶

       3: dup

       // 从常量池中取出字面量（常量值）

       4: ldc           #3                  // String helloworld

       6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V

       9: astore_1

      10: aload_1

      11: invokevirtual #5                  // Method java/lang/String.intern:()Ljava/lang/String;

      14: astore_2

      15: ldc           #3                  // String helloworld

      17: astore_3

      18: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;

      21: aload_1

      22: aload_2

      23: if_acmpne     30

      26: iconst_1

      27: goto          31

      30: iconst_0

      31: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V

      34: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;

      37: aload_3

      38: aload_2

      39: if_acmpne     46

      42: iconst_1

      43: goto          47

      46: iconst_0

      47: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V

      50: return

}

// String s0 = new String("helloworld") 的反编译源码

0: new           #2                  // class java/lang/String

3: dup

4: ldc           #3                  // String helloworld

6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V

9: astore_1

//  String s2 = "helloworld" 的反编译源码

15: ldc           #3                 // String helloworld

17: astore_3

// 对比可知，"helloworld"不会在堆中创建对象，即不调用new指令和String的构造器方法

// 但是只要看到"helloworld"，就会在'静态常量池'中生成"helloworld"字面量，后面还有个例子可以比较看看。

关于JVM指令，请参考：https://blog.csdn.net/hudashi/article/details/7062781

https://blog.csdn.net/hudashi/article/details/7062675

（2）通过Classpy查看静态常量池：

关于Classpy，请参考：https://github.com/zxh0/classpy

StringDemo.class

	magic:0xCAFEBABE

	...

	...

	constant_pool:

		#01 (Methodref): java/lang/Object.<init>

		#02 (Class): java/lang/String

		// 符号引用

		#03 (String): helloworld

			tag:8

			string_index:26

		...

		...

		// 字面量

		#26 (Utf8):hellowrold

			tag:1

			length:10

			bytes:helloworld

（3）intern方法（返回字符串的引用）

// 注释简言之：intern会判断字符串常量池是否拥有该字符串对象，拥有则返回，反之添加到常量池并返回该字符串对象的引用。

// 其中所有的字面量字符串和字符数值的常量表达式（请参考java规范）都会被常量池保存起来。

// 后面再详细讲解intern方法的内部实现

/**

* Returns a canonical representation for the string object.

* <p>

* A pool of strings, initially empty, is maintained privately by the

* class {@code String}.

* <p>

* 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.

* <p>

* 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}.

* <p>

* All literal strings and string-valued constant expressions are

* interned. String literals are defined in section 3.10.5 of the

* <cite>The Java&trade; 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.

* @jls 3.10.5 String Literals

*/

public native String intern();

java规范的下载地址：https://docs.oracle.com/javase/specs/index.html

2、new String("hello") + new String("world") 与 “helloworld”

public static void main(String[] args) throws Exception {

    	// new StringBuilder().append("hello").append("world").toString();

        String s0 = new String("hello") + new String("world");

        String s1 = s0.intern(); // 此时常量池没有helloworld,此时放入，放入的是s0的地址。

        String s2 = "helloworld"; // 从常量池中取出s0的地址

        System.out.println(s0 == s1); // true

        System.out.println(s2 == s1); // true

}

public static void main(String[] args) throws Exception {

        String s2 = "helloworld";

        String s0 = new String("hello") + new String("world");

        String s1 = s0.intern(); // 此时常量池有helloworld,直接取出，为s2的地址。

        System.out.println(s0 == s1); // false

        System.out.println(s2 == s1); // true

}

// 此例证明new StringBuilder().append("hello").append("world").toString()没有intern的功能

public static void main(String[] args) throws Exception {

        String s0 = new String("hello") + new String("world");

        String s2 = "helloworld"; // 具有intern的功能

        System.out.println(s2 == s0); // false

}

// StringBuilder的toString方法

@Override

@HotSpotIntrinsicCandidate

public String toString() {

    // Create a copy, don't share the array

    return isLatin1() ? StringLatin1.newString(value, 0, count): StringUTF16.newString(value, 0, count);

}

// StringLatin1.newString方法 ==> String的重载构造器

public static String newString(byte[] val, int index, int len) {

	return new String(Arrays.copyOfRange(val, index, index + len),LATIN1);

}

（1）对应的反编译源码

public static void main(java.lang.String[]) throws java.lang.Exception;

    Code:

       0: new           #2                  // class java/lang/StringBuilder

       3: dup

       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V

       7: new           #4                  // class java/lang/String

      10: dup

      11: ldc           #5                  // String hello

      13: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V

      16: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

      19: new           #4                  // class java/lang/String

      22: dup

      23: ldc           #8                  // String world

      25: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V

      28: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

      31: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

      34: astore_1

      35: aload_1

      36: invokevirtual #10                 // Method java/lang/String.intern:()Ljava/lang/String;

      39: astore_2

      40: ldc           #11                 // String helloworld

      42: astore_3

      43: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;

      46: aload_1

      47: aload_2

      48: if_acmpne     55

      51: iconst_1

      52: goto          56

      55: iconst_0

      56: invokevirtual #13                 // Method java/io/PrintStream.println:(Z)V

      59: getstatic     #12                 // Field java/lang/System.out:Ljava/io/PrintStream;

      62: aload_3

      63: aload_2

      64: if_acmpne     71

      67: iconst_1

      68: goto          72

      71: iconst_0

      72: invokevirtual #13                 // Method java/io/PrintStream.println:(Z)V

      75: return

}

（2）通过Classpy查看静态常量池：

检查静态常量池可知，只有"hello"和"world"，但是上述结果为true，代表执行intern时，运行常量池中放入了s0指向的地址。

（3）通过HSDB查看一下main线程的状态

代码通过jdb打断点停止在 String s1 = s0.intern();这一行。
cmd中，输入java -classpath "%JAVA_HOME%/lib/sa-jdi.jar" sun.jvm.hotspot.HSDB
点击右上角File -> Attach Hotspot process
点击Java Threads的main线程，点击Stack Memory...（左上角第二个）
查看Stack Memory for main，看到PSYoungGen java/langString 的地址：0x00000000d61515b8
点击Windows -> Console，输入inspect 0x00000000d61515b8,返回了instance of [C @ 0x00000000d61515d0 @ 0x00000000d61515d0 (size = 40)
Console Line中，继续输入inspect 0x00000000d61515d0 ,得到"helloworld"，代表new StringBuilder().toString()不会再常量池中放入字符串的引用。

断开HSDB的连接，代码通过jdb继续运行至System.out.println(s0 == s1);该行（HSDB连接时线程将阻塞，gdb无法直接调试，需要断开调试，再连接查看）
连接HSDB到虚拟机，明显可以看出main线程中的3个本地变量指向同一个字符串，对应s0、s1、s2.

HSDB，请参考：https://blog.csdn.net/kisimple/article/details/45128525

GBD，请参考：https://www.cnblogs.com/rocedu/p/6371262.html

二、String.intern()源码

由于intern方法是native方法，采用了JNI技术。

关于JNI技术，请参考：https://www.cnblogs.com/DengGao/p/jni.html

为了理解简单，下面源码省略了加锁、内存管理和重哈希的代码，感兴趣可以下载HotSpot的源码进行研读。

通过源码可以知道，String的常量池其实就是C++版本的HashMap而已。

下载源码，请参考：https://www.cnblogs.com/linzhanfly/p/9474173.html

// \openjdk10\jdk\src\share\native\java\lang\String.c

// 第二个参数为返回值

JNIEXPORT jobject JNICALL

// jni命名规范(声明为native自动生成)：java.lang.String:intern => Java_java_lang_String_intern（Java前缀 + 包名 + 方法名，分隔符号采用_）

Java_java_lang_String_intern(JNIEnv *env, jobject this){

    //（1）JVM_InternString调用

    return JVM_InternString(env, this);

}

// \openjdk10\hotspot\src\share\vm\prims\jvm.h

/*

 * java.lang.String

 */

JNIEXPORT jstring JNICALL

JVM_InternString(JNIEnv *env, jstring str);

// \openjdk10\hotspot\src\share\vm\prims\jvm.cpp

// String support ///////////////////////////////////////////////////////////////////////////

// （2）JVM_InternString的实现

JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))

  JVMWrapper("JVM_InternString");

  JvmtiVMObjectAllocEventCollector oam;

  if (str == NULL) return NULL;

  oop string = JNIHandles::resolve_non_null(str);

  // （3）StringTable::intern调用

  oop result = StringTable::intern(string, CHECK_NULL);

  return (jstring) JNIHandles::make_local(env, result);

JVM_END

// \openjdk10\hotspot\src\share\vm\classfile\stringTable.cpp

// （4）StringTable::intern的实现 StringTable是HashTable的子类

oop StringTable::intern(oop string, TRAPS){

  if (string == NULL) return NULL;

  int length;

  Handle h_string (THREAD, string); // 创建Handle

  jchar* chars = java_lang_String::as_unicode_string(string, length, CHECK_NULL);

  // （5）StringTable::intern的重载方法

  return intern(h_string, chars, length, CHECK_NULL);

}

// \openjdk10\hotspot\src\share\vm\classfile\stringTable.cpp

oop StringTable::intern(Handle string_or_null, jchar* name,int len, TRAPS) {

  // shared table always uses java_lang_String::hash_code

  // 个人理解: java_lang_String属于工具类，提供一些操作string的方法

  unsigned int hashValue = java_lang_String::hash_code(name, len);

  // （6）查询共享数组

  oop found_string = lookup_shared(name, len, hashValue);

  if (found_string != NULL) return found_string;

  // the_table()返回StringTable的引用

  int index = the_table() -> hash_to_index(hashValue);// 其实就是hashValue % _table_size

  found_string = the_table() -> lookup_in_main_table(index, name, len, hashValue);

  if (found_string != NULL) return found_string;

  Handle string;

  if (!string_or_null.is_null()) string = string_or_null;

  else string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);

  // 前面常量池存在该字符串就返回了，不存在则进行添加操作

  oop added_or_found = the_table()->basic_add(index,string,name,len,hashValue,CHECK_NULL);

  return added_or_found;

}

// \openjdk10\hotspot\src\share\vm\classfile\javaClasses.cpp

// hash_code的实现，与jdk源码String类的HashCode()方法类似

unsigned int java_lang_String::hash_code(oop java_string) {

  int length = java_lang_String::length(java_string);

  if (length == 0) return 0;

  typeArrayOop value  = java_lang_String::value(java_string);

  bool is_latin1 = java_lang_String::is_latin1(java_string);

  if (is_latin1) {

    // \openjdk10\hotspot\src\share\vm\classfile\javaClasses.hpp中static修饰的类方法

    return java_lang_String::hash_code(value->byte_at_addr(0), length);

  } else {

    // \openjdk10\hotspot\src\share\vm\classfile\javaClasses.hpp中static修饰的类方法

    return java_lang_String::hash_code(value->char_at_addr(0), length);

  }

}

// \openjdk10\hotspot\src\share\vm\classfile\javaClasses.hpp

static unsigned int hash_code(const jbyte* s, int len) {

    unsigned int h = 0;

    while (len-- > 0) {

      h = 31*h + (((unsigned int) *s) & 0xFF);

      s++;

    }

    return h;

}

// package java.lang.StringLatin1类中的hashCode与Openjdk中保持一致

public static int hashCode(byte[] value) {

    int h = 0;

    for (byte v : value) {

        h = 31 * h + (v & 0xff);

    }

    return h;

}

// \openjdk10\hotspot\src\share\vm\classfile\stringTable.cpp

oop StringTable::lookup_shared(jchar* name, int len, unsigned int hash) {

    //（7）共享数组是一个HashTable的子类， CompactHashtable<oop, char> StringTable::_shared_table;

    return _shared_table.lookup((const char*)name, hash, len);

}

// \openjdk10\hotspot\src\share\vm\classfile\compactHashtable.inline.hpp

template <class T, class N>

inline T CompactHashtable<T,N>::lookup(const N* name, unsigned int hash, int len) {

  if (_entry_count > 0) {//

    int index = hash % _bucket_count;// _bucket_count为_buckets数组大小

    u4 bucket_info = _buckets[index];// bucket_info为32位，高2位代表类型，低30为代表偏移量

    u4 bucket_offset = BUCKET_OFFSET(bucket_info);// 取出低30位

    int bucket_type = BUCKET_TYPE(bucket_info);// 取出高2位

    u4* entry = _entries + bucket_offset;// 根据偏移量取出entries数组中值

    if (bucket_type == VALUE_ONLY_BUCKET_TYPE) {

      // 只存值的entry，包含一个偏移量

      T res = decode_entry(this, entry[0], name, len);// 获取存放的值，代码就不贴了

      if (res != NULL) return res;

    } else {

      // This is a regular bucket, which has more than one

      // entries. Each entry is a pair of entry (hash, offset).

      // Seek until the end of the bucket.

      // 常规bucket，索引0放着hash值，索引1放着偏移量

      u4* entry_max = _entries + BUCKET_OFFSET(_buckets[index + 1]);// 获取下一个_buckets的偏移量作为寻找entry的最大值

      while (entry < entry_max) {

        if ((unsigned int)(entry[0]) == hash) {

          T res = decode_entry(this, entry[1], name, len);

          if (res != NULL) return res;

        }

        entry += 2;

      }

    }

  }

  return NULL;

}

// \openjdk10\hotspot\src\share\vm\classfile\stringTable.cpp

oop StringTable::lookup_in_main_table(int index, jchar* name,int len, unsigned int hash) {

  // bucket方法位于hashtable.inline.hpp中，与java的HashMap类似，取出HashtableEntry,类比Map.Entry.单向链表形式。

  // hash碰撞导致index相同，存放形式为链表。所以需要取出来对比hash值和内部值是否相等。

  // bucket(index) ==>  _buckets[i].get_entry();

  for (HashtableEntry<oop, mtSymbol>* l = bucket(index); l != NULL; l = l->next()) {

    // hash方法 ==> unsigned int hash() const { return _hash; }

    if (l->hash() == hash) {

      // literal方法取出oop,即String字面量 ==> T literal() const { return _literal;}

      if (java_lang_String::equals(l->literal(), name, len)) return l->literal();

    }

  }

  return NULL;

}

// \openjdk10\hotspot\src\share\vm\classfile\stringTable.cpp

oop StringTable::basic_add(int index_arg, Handle string, jchar* name,int len, unsigned int hashValue_arg, TRAPS) {

  unsigned int hashValue = hashValue_arg;

  int index = index_arg;

  oop test = lookup_in_main_table(index, name, len, hashValue);

  if (test != NULL)  return test;

  // \openjdk10\hotspot\src\share\vm\utilities\hashtable.cpp

  // StringTable继承了HashTable,()是Handle的运算符重载，返回string的对象值

  HashtableEntry<oop, mtSymbol>* entry = new_entry(hashValue, string());

  add_entry(index, entry);

  return string();

}

// \openjdk10\hotspot\src\share\vm\utilities\hashtable.inline.cpp

template <MEMFLAGS F> inline void BasicHashtable<F>::add_entry(int index, BasicHashtableEntry<F>* entry) {

  entry->set_next(bucket(index));

  _buckets[index].set_entry(entry);

  ++_number_of_entries;

}

// \openjdk10\hotspot\src\share\vm\runtime\handles.hpp

class Handle VALUE_OBJ_CLASS_SPEC {

    private:

    	oop* _handle;

	protected:

  		oop obj() const { return _handle == NULL ? (oop)NULL : *_handle; }// ()运算符重载

}

巴特西

作业10：String类

一、基本案例

1、new String("helloworld") 与 "helloworld"

（1）对比new String("helloworld")与"helloworld"的反编译源码

（2）通过Classpy查看静态常量池：

（3）intern方法（返回字符串的引用）

2、new String("hello") + new String("world") 与 “helloworld”

（1）对应的反编译源码

（2）通过Classpy查看静态常量池：

（3）通过HSDB查看一下main线程的状态

二、String.intern()源码

最新文章

热门文章