类加载流程004

最新推荐文章于 2021-04-08 00:57:02 发布
最新推荐文章于 2021-04-08 00:57:02 发布
阅读量1.3w 收藏
点赞数
分类专栏： openjdk openjdk 文章标签： java jvm jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26000415/article/details/90292122
版权

之前的几篇文章介绍了一堆klass对象的创建,本文我们来介绍一下 基本数组的创建. 这个和之前介绍的创建有所不同.

涉及到创建基本类型数组的代码如下:

_boolArrayKlassObj      = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
_charArrayKlassObj      = typeArrayKlass::create_klass(T_CHAR,    sizeof(jchar),    CHECK);
_singleArrayKlassObj    = typeArrayKlass::create_klass(T_FLOAT,   sizeof(jfloat),   CHECK);
_doubleArrayKlassObj    = typeArrayKlass::create_klass(T_DOUBLE,  sizeof(jdouble),  CHECK);
_byteArrayKlassObj      = typeArrayKlass::create_klass(T_BYTE,    sizeof(jbyte),    CHECK);
_shortArrayKlassObj     = typeArrayKlass::create_klass(T_SHORT,   sizeof(jshort),   CHECK);
_intArrayKlassObj       = typeArrayKlass::create_klass(T_INT,     sizeof(jint),     CHECK);
_longArrayKlassObj      = typeArrayKlass::create_klass(T_LONG,    sizeof(jlong),    CHECK);

_typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
_typeArrayKlassObjs[T_CHAR]    = _charArrayKlassObj;
_typeArrayKlassObjs[T_FLOAT]   = _singleArrayKlassObj;
_typeArrayKlassObjs[T_DOUBLE]  = _doubleArrayKlassObj;
_typeArrayKlassObjs[T_BYTE]    = _byteArrayKlassObj;
_typeArrayKlassObjs[T_SHORT]   = _shortArrayKlassObj;
_typeArrayKlassObjs[T_INT]     = _intArrayKlassObj;
_typeArrayKlassObjs[T_LONG]    = _longArrayKlassObj;

本文只介绍boolean数组的创建,其他几种的基本类型数组流程也是同样的.

在正式介绍之前,先介绍如下内容:

  1. jvm 内部中基本类型所对应的大小
  2. handle,oopHandle的定义

jvm 内部基本数据类型

在/hotspot/src/share/vm/prims/jni.h中,关于基本数据类型,有如下定义:

typedef unsigned char   jboolean;
typedef unsigned short  jchar;
typedef short           jshort;
typedef float           jfloat;
typedef double          jdouble;

typedef jint            jsize;

在/hotspot/src/cpu/x86/vm/jni_x86.h中,有如下定义:

typedef int jint;

#ifdef _LP64  // 如果是64位的话
typedef long jlong;
#else
typedef long long jlong; // 如果是32位的话
#endif

handle 家族的定义

handle的定义是在 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; }
  oop     non_null_obj() const                   { assert(_handle != NULL, "resolving NULL handle"); return *_handle; }

 public:
  // Constructors
  Handle()                                       { _handle = NULL; }
  Handle(oop obj);
#ifndef ASSERT
  Handle(Thread* thread, oop obj);
#else
  // Don't inline body with assert for current thread
  Handle(Thread* thread, oop obj);
#endif // ASSERT

  // General access
  oop     operator () () const                   { return obj(); }
  oop     operator -> () const                   { return non_null_obj(); }
  bool    operator == (oop o) const              { return obj() == o; }
  bool    operator == (const Handle& h) const          { return obj() == h.obj(); }

  // Null checks
  bool    is_null() const                        { return _handle == NULL; }
  bool    not_null() const                       { return _handle != NULL; }

  // Debugging
  void    print()                                { obj()->print(); }

  // Direct interface, use very sparingly.
  // Used by JavaCalls to quickly convert handles and to create handles static data structures.
  // Constructor takes a dummy argument to prevent unintentional type conversion in C++.
  Handle(oop *handle, bool dummy)                { _handle = handle; }

  // Raw handle access. Allows easy duplication of Handles. This can be very unsafe
  // since duplicates is only valid as long as original handle is alive.
  oop* raw_value()                               { return _handle; }
  static oop raw_resolve(oop *handle)            { return handle == NULL ? (oop)NULL : *handle; }
};

而 oophandle是通过宏定义来实现的,如下:

#define DEF_HANDLE(type, is_a)                   \
  class type##Handle;                            \
  class type##Handle: public Handle {            \
   protected:                                    \
    type##Oop    obj() const                     { return (type##Oop)Handle::obj(); } \
    type##Oop    non_null_obj() const            { return (type##Oop)Handle::non_null_obj(); } \
                                                 \
   public:                                       \
    /* Constructors */                           \
    type##Handle ()                              : Handle()                 {} \
    type##Handle (type##Oop obj) : Handle((oop)obj) {                         \
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(),             \
             "illegal type");                                                 \
    }                                                                         \
    type##Handle (Thread* thread, type##Oop obj) : Handle(thread, (oop)obj) { \
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(), "illegal type");  \
    }                                                                         \
    \
    /* Special constructor, use sparingly */ \
    type##Handle (type##Oop *handle, bool dummy) : Handle((oop*)handle, dummy) {} \
                                                 \
    /* Operators for ease of use */              \
    type##Oop    operator () () const            { return obj(); } \
    type##Oop    operator -> () const            { return non_null_obj(); } \
  };

// 定义oop家族的handle体系
DEF_HANDLE(instance         , is_instance         ) // 类实例handle
DEF_HANDLE(method           , is_method           ) // 方法实例handle
DEF_HANDLE(constMethod      , is_constMethod      ) // 方法字节码handle
DEF_HANDLE(methodData       , is_methodData       ) // 性能统计handle
DEF_HANDLE(array            , is_array            ) // 数组handle
DEF_HANDLE(constantPool     , is_constantPool     ) // 常量池handle
DEF_HANDLE(constantPoolCache, is_constantPoolCache) // 常量池缓存handle
DEF_HANDLE(objArray         , is_objArray         ) // 引用类型数组handle
DEF_HANDLE(typeArray        , is_typeArray        ) // 基本类型数组handle
DEF_HANDLE(symbol           , is_symbol           )

此处就拿symbolHandle来举例,其声明的内容如下:

  class symbolHandle;                            
  class symbolHandle: public Handle {            
   protected:                                    
    symbolOop    obj() const
    { return (symbolOop)Handle::obj(); } 
    
    symbolOop    non_null_obj() const             { return (symbolOop)Handle::non_null_obj(); } 
                                                 
   public:                                       
    /* Constructors */                           
    symbolHandle ()                              : Handle()                 {} 
    symbolHandle (symbolOop obj) : Handle((oop)obj) {                         
      assert(SharedSkipVerify || is_null() || ((oop)obj)-> is_symbol(),             
             "illegal type");                                                 
    } 
                                                                            
    symbolHandle (Thread* thread, symbolOop obj) : Handle(thread, (oop)obj) { 
      assert(SharedSkipVerify || is_null() || ((oop)obj)-> is_symbol(), "illegal type"); 
    }                                                                         
    
    /* Special constructor, use sparingly */ 
    symbolHandle (symbolOop *handle, bool dummy) : Handle((oop*)handle, dummy) {} 
                                                 
    /* Operators for ease of use */              
    symbolOop    operator () () const            { return obj(); } 
    symbolOop    operator -> () const            { return non_null_obj(); } 
  };

创建流程

  1. 调用如下代码创建 boolean类型的数组

    _boolArrayKlassObj      = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);

    这里注意的是,sizeof(jboolean) = sizeof(unsigned char)

  2. typeArrayKlass::create_klass 的代码如下:

     static inline klassOop create_klass(BasicType type, int scale, TRAPS) {
 return create_klass(type, scale, external_name(type), CHECK_NULL); }

    其调用external_name 获得指定类型数组的内部表示.其代码如下:

        const char* typeArrayKlass::external_name(BasicType type) {
   switch (type) {
     case T_BOOLEAN: return "[Z";
     case T_CHAR:    return "[C";
     case T_FLOAT:   return "[F";
     case T_DOUBLE:  return "[D";
     case T_BYTE:    return "[B";
     case T_SHORT:   return "[S";
     case T_INT:     return "[I";
     case T_LONG:    return "[J";
     default: ShouldNotReachHere();
   }
   return NULL;
  }

    因此,对于当前状况,其返回的是 [Z

  3. 执行typeArrayKlass::create_klass(BasicType type, int scale,const char* name_str, TRAPS) 方法,代码如下:

    	klassOop typeArrayKlass::create_klass(BasicType type, int scale,
                                      const char* name_str, TRAPS) {
  typeArrayKlass o;

  symbolHandle sym(symbolOop(NULL));
  // bootstrapping: don't create sym if symbolKlass not created yet
  if (Universe::symbolKlassObj() != NULL && name_str != NULL) {
    sym = oopFactory::new_symbol_handle(name_str, CHECK_NULL);
  }
  KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj());

  arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL);
  typeArrayKlass* ak = typeArrayKlass::cast(k());
  ak->set_name(sym());
  ak->set_layout_helper(array_layout_helper(type));
  assert(scale == (1 << ak->log2_element_size()), "scale must check out");
  assert(ak->oop_is_javaArray(), "sanity");
  assert(ak->oop_is_typeArray(), "sanity");
  ak->set_max_length(arrayOopDesc::max_array_length(type));
  assert(k()->size() > header_size(), "bad size");

  // Call complete_create_array_klass after all instance variables have been initialized.
  KlassHandle super (THREAD, k->super());
  complete_create_array_klass(k, super, CHECK_NULL);

  return k();
}

  4. 创建typeArrayKlass,symbolHandle.由于在创建基本类型数组前已创建了symbolKlassObj.因此会通过 oopFactory::new_symbol_handle(name_str, CHECK_NULL); 来创建Handle. 其最终执行的代码如下:

    	static symbolHandle    new_symbol_handle(const char* name, int length, TRAPS) {
  symbolOop sym = new_symbol(name, length, THREAD);
  return symbolHandle(THREAD, sym);}

    1. 获得symbolOop. 其最终执行的是SymbolTable::lookup(utf8_buffer, length, CHECK_NULL); 这里有必要介绍一下SymbolTable.其类图如下:

      1

      SymbolTable是在universe::universe_init中调用SymbolTable::create_table() 完成创建的.代码如下:

      SymbolTable* SymbolTable::_the_table = NULL;

static void create_table() {
   assert(_the_table == NULL, "One symbol table allowed.");
   _the_table = new SymbolTable();  }

      此时会执行其构造函数:

       SymbolTable() : Hashtable(symbol_table_size, sizeof (HashtableEntry)) {} // symbol_table_size = 20011

      接下来执行Hashtable的构造函数

      Hashtable(int table_size, int entry_size) : BasicHashtable(table_size, entry_size), _seed(0)  { }

      执行BasicHashtable的构造函数

          inline BasicHashtable::BasicHashtable(int table_size, int entry_size) {
     // Called on startup, no locking needed
     // 1. 初始化table_size, entry_size
     initialize(table_size, entry_size, 0);
     // 2. 在c堆上创建维度为table_size的HashtableBucket的数组
     _buckets = NEW_C_HEAP_ARRAY(HashtableBucket, table_size);
     for (int index = 0; index < _table_size; index++) {
       _buckets[index].clear();}}

      这里需要注意的是,默认情况下创建的是长度为20011的HashtableBucket的数组…

      这里介绍一下HashtableBucket.其类图如下:

      3

      HashtableBucket其内部指向HashtableEntry,而HashtableEntry实际上是一个链表. 因此, SymbolTable的数据结构就是数组+链表.

    2. 接下来,通过SymbolTable::lookup(const char* name, int len, TRAPS) 获得对应的symbolOop.其代码如下:

      symbolOop SymbolTable::lookup(const char* name, int len, TRAPS) {
   // 1. 获得该字符所对应的hash
   unsigned int hashValue = hash_symbol(name, len);
   // 2. 获得对应的index
   int index = the_table()->hash_to_index(hashValue);
 
   // 3. 在bucket中找寻symbol
   symbolOop s = the_table()->lookup(index, name, len, hashValue);
 
   // Found 4. 如果找到了,则直接返回
   if (s != NULL) return s;
 
   // We assume that lookup() has been called already, that it failed,
   // and symbol was not found.  We create the symbol here.
   // 5. 创建一个新的符号
   symbolKlass* sk  = (symbolKlass*) Universe::symbolKlassObj()->klass_part();
   symbolOop s_oop = sk->allocate_symbol((u1*)name, len, CHECK_NULL);
   symbolHandle sym (THREAD, s_oop);
 
   // Allocation must be done before grabbing the SymbolTable_lock lock 6. 获得锁
   MutexLocker ml(SymbolTable_lock, THREAD);
   // Otherwise, add to symbol to table 7. 添加符号
   return the_table()->basic_add(sym, index, (u1*)name, len, hashValue, CHECK_NULL);}

      这里重点看下第3步和第7步.其中第三步为:

        // Lookup a symbol in a bucket. 在bucket中找寻symbol
 
 symbolOop SymbolTable::lookup(int index, const char* name,
                               int len, unsigned int hash) {
   int count = 0;
    // 1.从对应的HashtableBucket开始查找
   for (HashtableEntry* e = bucket(index); e != NULL; e = e->next()) {
     count++;
     if (e->hash() == hash) {
       // 2. 如果找到对应的,则直接返回symbolOop
       symbolOop sym = symbolOop(e->literal());
       if (sym->equals(name, len)) {
         return sym;
       }
     }
   }
   // If the bucket size is too deep check if this hash code is insufficient.
   // 3.如果bucket 链太长，则检查是否需要rehash
   if (count >= BasicHashtable::rehash_count && !needs_rehashing()) {
     _needs_rehashing = check_rehash_table(count);
   }
   return NULL;	}

      添加的代码为:

      symbolOop SymbolTable::basic_add(symbolHandle sym, int index_arg, u1 *name, int len,
                              unsigned int hashValue_arg, TRAPS) {
// Cannot hit a safepoint in this function because the "this" pointer can move.
No_Safepoint_Verifier nsv;

assert(sym->equals((char*)name, len), "symbol must be properly initialized");

// Check if the symbol table has been rehashed, if so, need to recalculate
// the hash value and index.
// 1. 检查符号表是否已经重hash过了,如果是的话,则需要重新计算hash 值和index
unsigned int hashValue;
int index;
if (use_alternate_hashcode()) {
 hashValue = hash_symbol((const char*)name, len);
 index = hash_to_index(hashValue);
} else {
 hashValue = hashValue_arg;
 index = index_arg;
}

// Since look-up was done lock-free, we need to check if another
// thread beat us in the race to insert the symbol.
// 2. 检查是否有其他线程在我们前面完成了操作
symbolOop test = lookup(index, (char*)name, len, hashValue);
if (test != NULL) {
 // A race occurred and another thread introduced the symbol, this one
 // will be dropped and collected.
 return test;
}

// 3. 添加
HashtableEntry* entry = new_entry(hashValue, sym());
add_entry(index, entry);
return sym();}

      其中第三步首先获得sym所对应的symbolOop(对应的代码为sym(), symbolHandle 重载了() ). 然后执行Hashtable::new_entry 创建 HashtableEntry. 代码如下:

          HashtableEntry* Hashtable::new_entry(unsigned int hashValue, oop obj) {
     HashtableEntry* entry;
     entry = (HashtableEntry*)BasicHashtable::new_entry(hashValue);
     entry->set_literal(obj);   // clears literal string field
     HS_DTRACE_PROBE4(hs_private, hashtable__new_entry,
       this, hashValue, obj, entry);
     return entry;}

      这里实例化了HashtableEntry.并设置其hash值为hashValue,_literal 为Symboloop,然后调用BasicHashtable::add_entry 进行添加.代码如下:

       inline void BasicHashtable::add_entry(int index, BasicHashtableEntry* entry) {
     entry->set_next(bucket(index));
     _buckets[index].set_entry(entry);
     ++_number_of_entries;}

      注意,这里使用了链表的倒插法,其最终的结果是,后添加的HashtableEntry在链表的首部.

  5. 创建typeArrayKlassKlassObj所对应的KlassHandle. typeArrayKlassKlassObj在之前已经创建完必.代码如下:

     KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj());

  6. 接下来就是创建klassOop,这点和之前的文章类加载流程-002 流程是一样的,最终创建的结果如下:
    6

  7. 其他的基本类型数组和上文介绍的一样,不同的是分配的大小,数组的名称不同罢了. 之后保存到全局变量_typeArrayKlassObjs 中,代码如下:

    _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
_typeArrayKlassObjs[T_CHAR]    = _charArrayKlassObj;
_typeArrayKlassObjs[T_FLOAT]   = _singleArrayKlassObj;
_typeArrayKlassObjs[T_DOUBLE]  = _doubleArrayKlassObj;
_typeArrayKlassObjs[T_BYTE]    = _byteArrayKlassObj;
_typeArrayKlassObjs[T_SHORT]   = _shortArrayKlassObj;
_typeArrayKlassObjs[T_INT]     = _intArrayKlassObj;
_typeArrayKlassObjs[T_LONG]    = _longArrayKlassObj;
一个努力的码农
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
简析linux内核的内核执行流程.doc
11-29
* 0x00000 到 0x003FF 总共 1KB 存放中断向量表，而接下去的地址到 0x004FF 共 256B 存放 BIOS 数据，从 0x0E05B 开始的约 8KB 的内存中存放中断服务程序。 * 利用 BIOS 中断 0x19h 把硬盘的第一扇区 bootsect.s 的...
XpShop模板V3-004
12-16
在技术实现上，XpShop模板V3-004可能基于HTML5、CSS3和JavaScript构建，这使得页面加载更快，交互更流畅。同时，为了提高后台管理效率，可能使用了PHP编程语言配合MySQL数据库进行数据存储和处理。开发者可以通过...
openjdk hotspot源码分析之string.intern方法原理
qq_33678688的博客
04-08 507
java实现引用的方式 java实现引用有直接指针和句柄池2种方式，下面简单说下2种方式的区别和优缺点： 1.直接指针的实现方式是把obj的内存地址或者相对偏移量直接赋值给Java变量，其优点是直接定位，访问快，但是缺点也很明显，Java是一门gc语言，当发生gc时，需要移动obj的偏移量，那么，对应的指针也需要发生移动，但是，由于直接指针实现的引用，指针是在Java的变量里的，移动是非常困难的 ...
vmSymbols与vmSymbolHandles
wave_calmly的专栏
12-15 232
vmSymbols和vmSymbolHandles这两个都是只拥有静态成员和方法的class。 其定义在：\hotspot\src\share\vm\memory\vmSymbols.hpp 用来缓存JVM内部常用的symboleOop和symboleHandle。 例如：    symbolOop obj       = vmSymbols::java_lang_Object(); // jav...
null == obj 和 obj == null在java中推荐前者的原因
zlj1217的博客
05-30 5186
在公司会看到代码规范中有一条是在if判空条件中要写成  if (null == obj) 而不是 if (obj == null)，之前不理解这样写有什么区别，后来才知道其实就是避免把 == 写成赋值 = ，因为如果是Obj = null IDE此时不会报错；而当你写成  null = obj的话 IDE是会报错的，这里也算是一种规范。 有很多同学会说防止空指针
【JVM类加载机制】从一个对象的验证问题说开去
ISherry
01-25 929
0 引例前几天本人正在愉快的写代码的时候突然接到老大给的一个新任务，对支付相关的几个类做代码加密和安全性校验工作，确保类来源的安全性。 那么现在有了需求下一步就要来满足需求，这里采用的方案是在加载过程中进行类来源检测和代码解密的相关工作。接下来主要就是实现了一个类加载器。 经过一通操作终于实现好了这个加载器，经过测试也满足了类的相关解密和校验工作，可谓是完美。然而，帅不过三秒，接下来运行的时候傻
JVM操作符重载函数
三月泡生长在阳春三月天，把鲜红的美味奉献给世人
05-08 131
class Handle VALUE_OBJ_CLASS_SPEC { private: oop* _handle; protected: oop obj() const { return _handle == NULL ? (oop)NULL : *_handle; } oop non_null_obj()...
类加载流程006
qq_26000415的博客
05-21 1万+
本文来介绍SystemDictionary::initialize(Thread* the_thread).在此之前,先介绍一下SystemDictionary涉及的类图: 图中没有画出的是,SymbolPropertyTable,LoaderConstraintTable等,其内部存放的是SymbolPropertyEntry,LoaderConstraintEntry. 解析 SystemD...
详解JVM类加载机制
T_Kuuga的博客
04-08 188
笔者的笔记都记录在有道云里面，因为公司原因办公电脑无法使用有道云，正好借此机会整理下以前的笔记顺便当做巩固复习了，也因为记笔记的时候不会记录这些知识来源何地，所以如果发现原创后可找我，我会在后面加上原创链接。
asp.net代码练习 work004
06-05
ASP.NET是微软公司推出的一种用于构建Web应用程序的框架，它基于.NET Framework，为开发者提供了丰富的功能和工具，简化了Web应用的开发流程。在"asp.net代码练习 work004"这个项目中，我们可以深入学习和实践ASP...
【LGame学堂004.资源传说】 加载资源的方式 源码下载
05-09
4. **字体加载**：LGame支持自定义字体，通过Font类加载ttf字体文件，可以创建具有特定大小和样式的文本。 5. **异步加载机制**：LGame使用Loader类实现异步加载，通过监听器接口（如Loader.OnLoadCompleteListener...
SQL Server 2000 DTS Step by Step
12-08
DTS是SQL Server的重要组件，主要用于数据迁移、清洗和转换，广泛应用于数据仓库构建和ETL（提取、转换、加载）流程。 在《SQL Server 2000 DTS Step by Step Part004》中，我们可能会深入探讨以下几个关键知识点：...
oop-klass内存模型
热门推荐
qq_26000415的博客
03-01 1万+
只要是对JVM有所了解的,或多或少的都知道oop-klass模型.那么什么是oop-klass模型? JVM内部基于oop-klass模型描述一个java类,将一个java类分为两个部分进行描述,其中第一个模型是oop,第二个模型是klass. 接下来,本文从以下几个角度进行讲解: 宏观: 从整体上描述一下oop-klass模型 微观: 从类的继承结构上进行讲述,加深理解 宏观 JVM使用...
类文件解析006-解析接口
qq_26000415的博客
05-30 1万+
本文来介绍一下解析接口的部分,这部分的代码比较简单,算是为了给之后解析变量内容的减压. 为了内容的连贯性,先来看一下class文件的格式: ClassFile { u4 magic; u2 minor_version; u2 major_version; u2 constant_pool_count; --> 在调用ClassFileParser::...
类加载流程-002
qq_26000415的博客
03-01 1万+
本文让我们继续梳理类加载的流程,分析的代码为: _klassKlassObj = klassKlass::create_klass(CHECK); 这里先说明2个问题: 为啥要首先创建klassKlass? 因为klassKlass 是klass链路的末端.不可能oop-klass 一直这么的指下去,必须有个终点.这个终点就是klassKlass. CHECK 是啥? ...
类加载流程-01
qq_26000415的博客
03-01 1万+
从本文开始讲述类加载过程,在这里先解释一下类加载的时机是什么? 此时可以分为2种情况: 主动引用 被动引用 类的主动引用指的是: new一个类的对象 调用类的静态成员（除了final常量）和静态方法 使用java.lang.reflect包的方法对类进行反射调用 当虚拟机启动，java Demo01,则一定会初始化Demo01类，说白了就是先启动main方法所在的类 当初始化一个类，如果其父...
类文件解析003-解析常量池
qq_26000415的博客
05-28 1万+
本文我们来介绍ClassFileParser 解析常量池的过程.解析常量池的过程是在ClassFileParser::parseClassFile 通过parse_constant_pool 来实现的. 在parse_constant_pool 中的步骤如下: 获得常量池的长度 创建constantPoolOop 调用parse_constant_pool_entries 解析常量池操作 验证交...
类文件解析001
qq_26000415的博客
05-27 1万+
此处我们开始踏上类文件解析的道路.在此之前,我们已经讲解了类加载的流程,而在类加载的流程的过程中,涉及到类文件解析的过程,由于过程很复杂,因此用一个系列来进行介绍.(其实,在之前介绍的类加载的流程可以准确的).在此处贴下之前的博客目录: oop-klass内存模型 类加载流程-01 类加载流程-002 类加载流程003 类加载流程004 类加载流程005 类加载流程006 解析 此处先介绍一...
Java class 类加载流程
最新发布
06-09
1. 加载：将类的字节码文件加载到内存中，并在内存中创建一个代表该类的java.lang.Class对象。 2. 链接：将已经加载的类与其他类和接口进行链接。链接的过程又可以分为三个步骤： * 验证：验证类的字节码文件是否...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值