JVM源码剖析之SymbolTable和StringTable

这篇具有很好参考价值的文章主要介绍了JVM源码剖析之SymbolTable和StringTable。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

很多读者在观看JVM相关的书籍时会看到SymbolTable和StringTable,书中的三言二语介绍的不是很清楚,并且读者的水平有限,导致无法理解SymbolTable和StringTable。所以特意写此篇图文并茂的文章来彻底理解SymbolTable和StringTable这两张表。

版本信息如下:

jdk版本:jdk8u40

因为Hotspot是c++构成,所以也存在面向对象的思想,也即存在类和对象,所以直接看到SymbolTable和StringTable的类定义即可。src/share/vm/classfile/symbolTable.hpp 文件中

// key为Symbol,value为mtSymbol
class SymbolTable : public Hashtable<Symbol*, mtSymbol> {
  friend class VMStructs;
  friend class ClassFileParser;

  // The symbol table
  static SymbolTable* _the_table;
  
}
// key为oop,value为mtSymbol
class StringTable : public Hashtable<oop, mtSymbol> {
  friend class VMStructs;

  // The string table
  static StringTable* _the_table;
}

可以非常清楚的看到2者都继承了Hashtable,也更加肯定2者就是一张表。而Hashtable可以理解为Java中HashMap结构(数组+链表+特定条件下的红黑树)。而谈到map结构一定会出现key,value的映射关系。

SymbolTable:key是Symbol,Symbol可以理解为utf8编码的字符信息

SymbolTable:value是mtSymbol,这是一个枚举值,仅仅表示内存的解释,不起实际作用

——————————————————————

StringTable:key是oop,oop可以理解为Java对象地址(实际上存放的就是Java的String对象)

StringTable:value是mtSymbol,这是一个枚举值,仅仅表示内存的解释,不起实际作用

JVM源码剖析之SymbolTable和StringTable,Java底层,源码解读,jvm,Hotspot源码,Java

JVM源码剖析之SymbolTable和StringTable,Java底层,源码解读,jvm,Hotspot源码,Java 

既然已经明白SymbolTable和StringTable的大致作用了,那么下面就是源码查看如何使用。

SymbolTable使用

从上文,我们清楚明白SymbolTable中存放的是Symbol对象,而Symbol对象存放的是utf8编码的字符。所以utf8编码的字符来自何处呢? 

下面从一个很简单的例子来分析

public class demo{
  public static void main(String[] args)  {
     System.out.println("123");
  }
}

简单的查看一下字节码的表示

Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // 123
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // demo
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               demo.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               123
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               demo
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String 123
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 4: 0
        line 5: 8
}
SourceFile: "demo.java"

可以看到字节码常量池中存在很多Utf8的字段,那是不是这些常量池中Utf8的字段会解析成Symbol对象呢?抱着疑问,我们看到Hotspot中解析字节码常量池的源码。src/share/vm/classfile/classFileParser.cpp 文件中。

void ClassFileParser::parse_constant_pool_entries(int length, TRAPS) {

  // 解析常量池,从下标#1开始
  for (int index = 1; index < length; index++) {

    // 拿到下标对应的tag,比如拿到Utf8、Class、String、NameAndType等等....
    u1 tag = cfs->get_u1_fast();

    // 根据一个字节的tag区分后续。
    switch (tag) {
      
      ………… 
      // 省略了其他tag的解析,我们只关心Utf8的解析。

      case JVM_CONSTANT_Utf8 :
        {
          cfs->guarantee_more(2, CHECK);  // utf8_length
          // 根据长度解析
          u2  utf8_length = cfs->get_u2_fast();
          u1* utf8_buffer = cfs->get_u1_buffer();

          unsigned int hash;
          // 从SymbolTable中尝试获取,如果存在就直接获取,如果不存在就创建。
          Symbol* result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);
          if (result == NULL) {
            names[names_count] = (char*)utf8_buffer;
            lengths[names_count] = utf8_length;
            indices[names_count] = index;
            hashValues[names_count++] = hash;
            // 把Symbol添加到SymbolTable中
            // 因为在常量池中最多的就是Utf8项,所以为了优化,这里采用批处理
            // 如果当前常量池中Utf8项数量每8的倍数就一次性插入一轮。
            if (names_count == SymbolTable::symbol_alloc_batch_size) {
              SymbolTable::new_symbols(_loader_data, _cp, names_count, names, lengths, indices, hashValues, CHECK);
              names_count = 0;
            }
          } else {
            // 添加到常量池中。
            _cp->symbol_at_put(index, result);
          }
        }
        break;
      default:
        classfile_parse_error(
          "Unknown constant tag %u in class file %s", tag, CHECK);
        break;
    }
  }
  // 把Symbol添加到SymbolTable中
  // 如果没有批处理,那终究还是得插入。
  if (names_count > 0) {
    SymbolTable::new_symbols(_loader_data, _cp, names_count, names, lengths, indices, hashValues, CHECK);
  }
}

这里解析Utf8项,拿到Utf8的值,上文字节码常量池第#18项的 123 ,尝试去SymbolTable中拿到123对应的Symbol,如果不存在就创建Symbol对象并添加到SymbolTable,如果存在就直接获取Symbol对象放入到常量池对象中。

除了常量池第#18项,还有第#21、#22、#23、#24、#25...... 众多Utf8项。并且其他常量池项最终都是指向到Utf8项,所以也能看明白Utf8项或者说Symbol的作用是啥了。存放类名、字符串数据、方法签名、方法名。一言以蔽之:Utf8项最终会解析成Symbol,而Symbol存放Java程序中所需的元数据、真实数据。而SymbolTable作为一个载体存放所有的Symbol

StringTable使用

还是使用SymbolTable的案例。

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // 把2号常量池的静态变量押入操作数栈
         3: ldc           #3                  // 把3号常量池的字符串解析成String对象,并且押入操作数栈
         5: invokevirtual #4                  // 执行4号常量池的方法,并且消耗2个操作数栈
         8: return                          
      LineNumberTable:
        line 4: 0
        line 5: 8

JVM源码剖析之SymbolTable和StringTable,Java底层,源码解读,jvm,Hotspot源码,Java

 所以,我们需要去源码论证ldc字节码指令如何创建出String对象。这里为了源码简单,使用C++字节码解释器作为了论证。src/share/vm/interpreter/bytecodeInterpreter.cpp 文件

CASE(_ldc):
{
  …………
  省略其他的处理

  ConstantPool* constants = METHOD->constants();
  switch (constants->tag_at(index).value()) {

  …………
  省略其他的处理

  case JVM_CONSTANT_String:
    {
      // 从常量池的对象池中拿对象
      oop result = constants->resolved_references()->obj_at(index);
      // 如果不存在
      if (result == NULL) {
        // 解析ldc,生成String对象。
        CALL_VM(InterpreterRuntime::resolve_ldc(THREAD, (Bytecodes::Code) opcode), handle_exception);
        // 线程变量是可以在线程中任意地方存取,并且线程安全。
        // 这里把String对象添加到操作数栈中
        SET_STACK_OBJECT(THREAD->vm_result(), 0);
        THREAD->set_vm_result(NULL);
      } else {    // 如果存在就直接添加到操作数栈中。
        VERIFY_OOP(result);
        SET_STACK_OBJECT(result, 0);
      }
    break;
    }

    …………
    省略其他的处理
  }
  UPDATE_PC_AND_TOS_AND_CONTINUE(incr, 1);
}

继续往InterpreterRuntime::resolve_ldc 方法看

IRT_ENTRY(void, InterpreterRuntime::resolve_ldc(JavaThread* thread, Bytecodes::Code bytecode)) {
  assert(bytecode == Bytecodes::_fast_aldc ||
         bytecode == Bytecodes::_fast_aldc_w, "wrong bc");
  ResourceMark rm(thread);
  methodHandle m (thread, method(thread));
  Bytecode_loadconstant ldc(m, bci(thread));
  // 解析
  oop result = ldc.resolve_constant(CHECK);
  thread->set_vm_result(result);
}
IRT_END

oop Bytecode_loadconstant::resolve_constant(TRAPS) const {
  assert(_method.not_null(), "must supply method to resolve constant");
  int index = raw_index();
  ConstantPool* constants = _method->constants();
  // 解析
  return constants->resolve_constant_at(index, THREAD);
}

oop ConstantPool::resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS) {
  oop result_oop = NULL;
  Handle throw_exception;
  int tag_value = this_oop->tag_at(index).value();

  switch (tag_value) {
  …………
  省略其他的处理

  case JVM_CONSTANT_String:
    // 拿到String对象
    result_oop = string_at_impl(this_oop, index, cache_index, CHECK_NULL);
    break;

  …………
  省略其他的处理
  
  }

  …………
  省略其他的处理
  return result_oop;
}

oop ConstantPool::string_at_impl(constantPoolHandle this_oop, int which, int obj_index, TRAPS) {
  // 从常量池中的对象池中尝试拿到缓存对象。
  oop str = this_oop->resolved_references()->obj_at(obj_index);
  if (str != NULL) return str;

  // 拿到ldc指向常量池下标最终对应的Utf8项
  // 而从上文讲述的SymbolTable可以得知,Utf8项在JVM中使用Symbol对象表示。
  // 所以这里拿到Symbol对象,而拿到Symbol对象,就拿到了具体数据
  Symbol* sym = this_oop->unresolved_string_at(which);

  // 尝试从StringTable中拿到String对象,如果存在就返回,如果不存在就创建并返回。
  str = StringTable::intern(sym, CHECK_(NULL));
  // 把对象添加到常量池中的对象池中
  this_oop->string_at_put(which, obj_index, str);
  return str;
}

由于调用栈比较深,所以这里对以上的代码做一个总结:

  1. 拿到 ldc 字节码指令指向常量池的代表,拿案例来说,也即拿到下标#3,也即拿到常量池String项
  2. String项指向下标#18 Utf8项
  3. 而从上文讲述的SymbolTable可以得知,Utf8项在JVM中使用Symbol对象表示。所以这里拿到Symbol对象,而拿到Symbol对象,就拿到了具体数据,也即拿到具体数据 123
  4. 拿到Symbol对象后会调用StringTable::intern方法,所以下文继续关注此方法
oop StringTable::intern(Symbol* symbol, TRAPS) {
  if (symbol == NULL) return NULL;
  ResourceMark rm(THREAD);
  int length;
  // 把utf8字符串转换成unicode编码。
  jchar* chars = symbol->as_unicode(length);
  Handle string;
  oop result = intern(string, chars, length, CHECK_NULL);
  return result;
}


oop StringTable::intern(Handle string_or_null, jchar* name,
                        int len, TRAPS) {
  // 上文得知,StringTable就是一张hash表。所以这里计算下标。
  unsigned int hashValue = hash_string(name, len);
  int index = the_table()->hash_to_index(hashValue);
  oop found_string = the_table()->lookup(index, name, len, hashValue);

  // 命中缓存,直接返回
  if (found_string != NULL) return found_string;

  // 因为没有命中缓存,所以需要创建一个String对象,并且添加到StringTable中
  // 在Java堆创建一个String对象。
  string = java_lang_String::create_from_unicode(name, len, CHECK_NULL);

  // 把创建出来的String对象,添加到StringTable中。
  return the_table()->basic_add(index, string, name, len,
                                hashValue, CHECK_NULL);
}

这里就非常明显了,把Symbol对象中的值拿出来,然后去StringTable中尝试命中缓存,如果命中就直接返回。如果没有命中就创建Java的String对象并添加到StringTable中。

所以,一言以蔽之:StringTable 管理了多个Java中String对象。而这些String对象是根据常量池String项对应的Utf8项(Symbol)生成的

SymbolTable和StringTable区别

从上文对SymbolTable和StringTable的介绍完全可以得知,这两张表的职责完全不一样。SymbolTable是存储Java项目中元数据、真实数据。而StringTable是储存Java中String对象。

硬要说有点关联的话,就是StringTable的数据来源于SymbolTable。文章来源地址https://www.toymoban.com/news/detail-534706.html

到了这里,关于JVM源码剖析之SymbolTable和StringTable的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++】:STL源码剖析之vector类容器的底层模拟实现

    构造一个空vector size和capacity为0 将_start _finish _endofstorage 都置为空指针即可 传统写法 : 1). 新开辟一块和 v 同样容量的空间,更新 _start, _finish, _endofstorage 2). 将 v 中的数据拷贝到新开辟的空间中 注意 : 不要使用memcpy函数拷贝数据,如果数据是内置类型或浅拷贝的自定义类型

    2024年02月04日
    浏览(51)
  • JVM源码剖析之Thread类中sleep方法

    版本信息: jdk版本:jdk8u40 大部分的Java程序员知道让线程睡眠的方法是Thread.sleep方法,而这个方法是一个native方法,让很多想知道底层如何让线程睡眠的程序员望而却步。所以笔者特意写在这篇文章,带各位读者剖析一下Thread.sleep方法背后的神秘。 话不多说,先从Java层面看

    2024年02月07日
    浏览(44)
  • 01-从JDK源码级别剖析JVM类加载机制

    上一篇:JVM虚拟机调优大全 当我们用java命令运行某个类的main函数启动程序时,首先需要通过类加载器把主类加载到JVM。 通过Java命令执行代码的大体流程如下: 其中loadClass的类加载过程有如下几步: 加载 验证 准备 解析 初始化 使用 卸载 加载:在硬盘上查找并通过IO读入字

    2024年02月09日
    浏览(35)
  • jvm深入研究文档--java中的堆--详解!--jvm底层探索(1)

    JVM的内存分区包括以下几个部分: 堆区(Heap) - 这是JVM的主要部分,用于存储实例对象和大多数Java对象,如数组和用户定义的类。 方法区(Method Area) - 这是线程私有的,用于存放类对象(加载好的类)。 栈区(Stack) - 这是线程私有的,包括虚拟机栈和本地方法栈。虚拟

    2024年02月07日
    浏览(49)
  • Linux源码解读系列是一套深入剖析Linux内核源码的教程,旨在帮助读者理解Linux操作系统的底层原理和工作机制

    Linux源码解读系列是一套深入剖析Linux内核源码的教程,旨在帮助读者理解Linux操作系统的底层原理和工作机制。该系列教程从Linux内核的各个模块入手,逐一分析其源码实现,并结合实际应用场景进行讲解。通过学习本系列,读者可以深入了解Linux操作系统的底层机制,掌握

    2024年01月21日
    浏览(47)
  • “深入剖析JVM内部原理:解密Java虚拟机的奥秘“

    标题:深入剖析JVM内部原理:解密Java虚拟机的奥秘 摘要:本文将深入探讨Java虚拟机(JVM)的内部原理,包括其架构、内存管理、垃圾回收机制、即时编译器等关键组成部分。通过解密JVM的奥秘,我们将更好地理解Java程序的执行过程,并能够优化代码的性能。 正文: 一、

    2024年02月13日
    浏览(42)
  • “深入剖析JVM内部机制:理解Java虚拟机的工作原理“

    标题:深入剖析JVM内部机制:理解Java虚拟机的工作原理 介绍: Java虚拟机(JVM)是Java语言的核心组件,负责将Java源代码转换为可以在计算机上运行的机器码。了解JVM的内部机制对于开发人员来说非常重要,因为它可以帮助我们更好地理解Java程序的运行行为和性能优化。本文

    2024年02月12日
    浏览(45)
  • “深入剖析JVM内部机制:探索Java虚拟机的运行原理“

    标题:深入剖析JVM内部机制:探索Java虚拟机的运行原理 摘要:本文将深入探讨Java虚拟机(JVM)的内部机制,包括类加载、内存管理、垃圾回收、即时编译等关键概念和原理,帮助开发者更好地理解JVM的运行机制。 正文: 一、类加载机制 Java虚拟机通过类加载机制将字节码文

    2024年02月14日
    浏览(60)
  • “深入剖析JVM内部机制:了解Java虚拟机的工作原理“

    标题:深入剖析JVM内部机制:了解Java虚拟机的工作原理 摘要:本文将深入剖析JVM内部机制,详细介绍Java虚拟机的工作原理。我们将探讨JVM的组成部分、类加载过程、内存管理、垃圾回收以及即时编译等关键概念。此外,还将提供示例代码来帮助读者更好地理解JVM的内部机制

    2024年02月11日
    浏览(42)
  • 【从JVM看Java,三问继承和多态,是什么?为什么?怎么做?深度剖析JVM的工作原理】

    《计算机底层原理专栏》:欢迎大家订阅学习,能够帮助到各位就是对我最大的鼓励! 文章目录 系列文章目录 前言 一、JVM是什么 二、 什么是继承 三、 什么是多态 总结         这篇文章聚焦JVM的实现原理,我更专注于从一个语言的底层原理,去剖析他的语法所实现的意义

    2024年02月05日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包