handles.hpp:Handle && KlassHandle

最新推荐文章于 2022-08-18 17:47:25 发布
原创 最新推荐文章于 2022-08-18 17:47:25 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入剖析了HotSpot虚拟机中handles模块的源代码，详细介绍了不同类型的对象句柄及类句柄的具体实现细节，包括构造函数、成员函数等。

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

//------------------------------------------------------------------------------------------------------------------------
// Specific Handles for different oop types
#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(); } \
  };

/*
DEF_HANDLE(instance         , is_instance         )
DEF_HANDLE(method           , is_method           )
DEF_HANDLE(constMethod      , is_constMethod      )
DEF_HANDLE(methodData       , is_methodData       )
DEF_HANDLE(array            , is_array            )
DEF_HANDLE(constantPool     , is_constantPool     )
DEF_HANDLE(constantPoolCache, is_constantPoolCache)
DEF_HANDLE(objArray         , is_objArray         )
DEF_HANDLE(typeArray        , is_typeArray        )
*/
//------------------------------------------------------------------------------------------------------------------------
// Specific KlassHandles for different Klass types

#define DEF_KLASS_HANDLE(type, is_a)             \
  class type##Handle : public KlassHandle {      \
   public:                                       \
    /* Constructors */                           \
    type##Handle ()                              : KlassHandle()           {} \
    type##Handle (klassOop obj) : KlassHandle(obj) {                          \
      assert(SharedSkipVerify || is_null() || obj->klass_part()->is_a(),      \
             "illegal type");                                                 \
    }                                                                         \
    type##Handle (Thread* thread, klassOop obj) : KlassHandle(thread, obj) {  \
      assert(SharedSkipVerify || is_null() || obj->klass_part()->is_a(),      \
             "illegal type");                                                 \
    }                                                                         \
                                                 \
    /* Access to klass part */                   \
    type*        operator -> () const            { return (type*)obj()->klass_part(); } \
                                                 \
    static type##Handle cast(KlassHandle h)      { return type##Handle(h()); } \
                                                 \
  };

/*
DEF_KLASS_HANDLE(instanceKlass         , oop_is_instance_slow )
DEF_KLASS_HANDLE(methodKlass           , oop_is_method        )
DEF_KLASS_HANDLE(constMethodKlass      , oop_is_constMethod   )
DEF_KLASS_HANDLE(klassKlass            , oop_is_klass         )
DEF_KLASS_HANDLE(arrayKlassKlass       , oop_is_arrayKlass    )
DEF_KLASS_HANDLE(objArrayKlassKlass    , oop_is_objArrayKlass )
DEF_KLASS_HANDLE(typeArrayKlassKlass   , oop_is_typeArrayKlass)
DEF_KLASS_HANDLE(arrayKlass            , oop_is_array         )
DEF_KLASS_HANDLE(typeArrayKlass        , oop_is_typeArray_slow)
DEF_KLASS_HANDLE(objArrayKlass         , oop_is_objArray_slow )
DEF_KLASS_HANDLE(constantPoolKlass     , oop_is_constantPool  )
DEF_KLASS_HANDLE(constantPoolCacheKlass, oop_is_constantPool  )
*/

class instanceHandle;
class instanceHandle : public Handle {
protected:
    instanceOop obj() const {
        return (instanceOop)Handle::obj();
    }

    instanceOop non_null_obj() const {
        return (instanceOop)Handle::non_null_obj();
    }
public:
    instanceHandle() : Handle() {
    }
    instanceHandle(instanceOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_instance(), "illegal type");
    }
    instanceHandle(Thread* thread, instanceOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_instance(), "illegal type");
    }
    instanceHandle(instanceOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    instanceOop operator () () const {
        return obj();
    }
    instanceOop operator -> () const {
        return non_null_obj();
    }
};

class methodHandle;
class methodHandle : public Handle {
protected: 
    methodOop obj() const {
        return (methodOop)Handle::obj();
    }
    methodOop non_null_obj() const {
        return (methodOop)Handle::non_null_obj();
    }
public: 
    methodHandle() : Handle() {
    }
    methodHandle(methodOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_method(), "illegal type");
    }
    methodHandle(Thread* thread, methodOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_method(), "illegal type");
    }
    methodHandle(methodOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    methodOop operator () () const {
        return obj();
    }
    methodOop operator -> () const {
        return non_null_obj();
    }
};

class constMethodHandle;
class constMethodHandle : public Handle {
protected: 
    constMethodOop obj() const {
        return (constMethodOop)Handle::obj();
    }
    constMethodOop non_null_obj() const {
        return (constMethodOop)Handle::non_null_obj();
    }
public: 
    constMethodHandle() : Handle() {
    }
    constMethodHandle(constMethodOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constMethod(), "illegal type");
    }
    constMethodHandle(Thread* thread, constMethodOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constMethod(), "illegal type");
    }
    constMethodHandle(constMethodOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    constMethodOop operator () () const {
        return obj();
    }
    constMethodOop operator -> () const {
        return non_null_obj();
    }
};

class methodDataHandle;
class methodDataHandle : public Handle {
protected: 
    methodDataOop obj() const {
        return (methodDataOop)Handle::obj();
    }
    methodDataOop non_null_obj() const {
        return (methodDataOop)Handle::non_null_obj();
    }
public:
    methodDataHandle() : Handle() {
    }
    methodDataHandle(methodDataOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_methodData(), "illegal type");
    }
    methodDataHandle(Thread* thread, methodDataOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_methodData(), "illegal type");
    }
    methodDataHandle(methodDataOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    methodDataOop operator () () const {
        return obj();
    }
    methodDataOop operator -> () const {
        return non_null_obj();
    }
};

class arrayHandle;
class arrayHandle : public Handle {
protected: 
    arrayOop obj() const {
        return (arrayOop)Handle::obj();
    }
    arrayOop non_null_obj() const {
        return (arrayOop)Handle::non_null_obj();
    }
public: 
    arrayHandle() : Handle() {
    }
    arrayHandle(arrayOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_array(), "illegal type");
    }
    arrayHandle(Thread* thread, arrayOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_array(), "illegal type");
    }
    arrayHandle(arrayOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    arrayOop operator () () const {
        return obj();
    }
    arrayOop operator -> () const {
        return non_null_obj();
    }
};

class constantPoolHandle;
class constantPoolHandle : public Handle {
protected: 
    constantPoolOop obj() const {
        return (constantPoolOop)Handle::obj();
    }
    constantPoolOop non_null_obj() const {
        return (constantPoolOop)Handle::non_null_obj();
    }
public: 
    constantPoolHandle() : Handle() {
    }
    constantPoolHandle(constantPoolOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPool(), "illegal type");
    }
    constantPoolHandle(Thread* thread, constantPoolOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPool(), "illegal type");
    }
    constantPoolHandle(constantPoolOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    constantPoolOop operator () () const {
        return obj();
    }
    constantPoolOop operator -> () const {
        return non_null_obj();
    }
};

class constantPoolCacheHandle;
class constantPoolCacheHandle : public Handle {
protected: 
    constantPoolCacheOop obj() const {
        return (constantPoolCacheOop)Handle::obj();
    }
    constantPoolCacheOop non_null_obj() const {
        return (constantPoolCacheOop)Handle::non_null_obj();
    }
public: 
    constantPoolCacheHandle() : Handle() {
    }
    constantPoolCacheHandle(constantPoolCacheOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPoolCache(), "illegal type");
    }
    constantPoolCacheHandle(Thread* thread, constantPoolCacheOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPoolCache(), "illegal type");
    }
    constantPoolCacheHandle(constantPoolCacheOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    constantPoolCacheOop operator () () const {
        return obj();
    }
    constantPoolCacheOop operator -> () const {
        return non_null_obj();
    }
};

class objArrayHandle;
class objArrayHandle : public Handle {
protected:
    objArrayOop obj() const {
        return (objArrayOop)Handle::obj();
    }
    objArrayOop non_null_obj() const {
        return (objArrayOop)Handle::non_null_obj();
    }
public: 
    objArrayHandle() : Handle() {
    }
    objArrayHandle(objArrayOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_objArray(), "illegal type");
    }
    objArrayHandle(Thread* thread, objArrayOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_objArray(), "illegal type");
    }
    objArrayHandle(objArrayOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    objArrayOop operator () () const {
        return obj();
    }
    objArrayOop operator -> () const {
        return non_null_obj();
    }
};

class typeArrayHandle;
class typeArrayHandle : public Handle {
protected: 
    typeArrayOop obj() const {
        return (typeArrayOop)Handle::obj();
    }
    typeArrayOop non_null_obj() const {
       return (typeArrayOop)Handle::non_null_obj();
    }
public:
    typeArrayHandle() : Handle() {
    }
    typeArrayHandle(typeArrayOop obj) : Handle((oop)obj) {
            assert(SharedSkipVerify || is_null() || ((oop)obj)->is_typeArray(), "illegal type");
    }
    typeArrayHandle(Thread* thread, typeArrayOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_typeArray(), "illegal type");
    }
    typeArrayHandle(typeArrayOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    typeArrayOop operator () () const {
        return obj();
    }
    typeArrayOop operator -> () const {
        return non_null_obj();
    }
};

class instanceKlassHandle : public KlassHandle {
public: 
    instanceKlassHandle() : KlassHandle() {
    }
    instanceKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_instance_slow(), "illegal type");
    }
    instanceKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_instance_slow(), "illegal type");
    }
    instanceKlass* operator -> () const {
        return (instanceKlass*)obj()->klass_part();
    }
    static instanceKlassHandle cast(KlassHandle h) {
        return instanceKlassHandle(h());
    }
};

class methodKlassHandle : public KlassHandle {
public:
    methodKlassHandle() : KlassHandle() {
    }
    methodKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_method(), "illegal type");
    }
    methodKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_method(), "illegal type");
    }
    methodKlass* operator -> () const {
        return (methodKlass*)obj()->klass_part();
    }
    static methodKlassHandle cast(KlassHandle h) {
        return methodKlassHandle(h());
    }
};

class constMethodKlassHandle : public KlassHandle {
public:
    constMethodKlassHandle() : KlassHandle() {
    }
    constMethodKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constMethod(), "illegal type");
    }
    constMethodKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constMethod(), "illegal type");
    }
    constMethodKlass* operator -> () const {
        return (constMethodKlass*)obj()->klass_part();
    }
    static constMethodKlassHandle cast(KlassHandle h) {
        return constMethodKlassHandle(h());
    }
};

class klassKlassHandle : public KlassHandle {
public: 
    klassKlassHandle() : KlassHandle() {
    }
    klassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_klass(), "illegal type");
    }
    klassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_klass(), "illegal type");
    }
    klassKlass* operator -> () const {
        return (klassKlass*)obj()->klass_part();
    }
    static klassKlassHandle cast(KlassHandle h) {
        return klassKlassHandle(h());
    }
};

class arrayKlassKlassHandle : public KlassHandle {
public: 
    arrayKlassKlassHandle() : KlassHandle() {
    }
    arrayKlassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_arrayKlass(), "illegal type");
    }
    arrayKlassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_arrayKlass(), "illegal type");
    }
    arrayKlassKlass* operator -> () const {
        return (arrayKlassKlass*)obj()->klass_part();
    }
    static arrayKlassKlassHandle cast(KlassHandle h) {
        return arrayKlassKlassHandle(h());
    }
};

class objArrayKlassKlassHandle : public KlassHandle {
public: 
    objArrayKlassKlassHandle() : KlassHandle() {
    }
    objArrayKlassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArrayKlass(), "illegal type");
    }
    objArrayKlassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArrayKlass(), "illegal type");
    }
    objArrayKlassKlass* operator -> () const {
        return (objArrayKlassKlass*)obj()->klass_part();
    }
    static objArrayKlassKlassHandle cast(KlassHandle h) {
        return objArrayKlassKlassHandle(h());
    }
};

class typeArrayKlassKlassHandle : public KlassHandle {
public: 
    typeArrayKlassKlassHandle() : KlassHandle() {
    }
    typeArrayKlassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArrayKlass(), "illegal type");        
    }
    typeArrayKlassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArrayKlass(), "illegal type");
    }
    typeArrayKlassKlass* operator -> () const {
        return (typeArrayKlassKlass*)obj()->klass_part();
    }
    static typeArrayKlassKlassHandle cast(KlassHandle h) {
        return typeArrayKlassKlassHandle(h());
    }
};

class arrayKlassHandle : public KlassHandle {
public: 
    arrayKlassHandle() : KlassHandle() {
    }
    arrayKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_array(), "illegal type");
    }
    arrayKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_array(), "illegal type");
    }
    arrayKlass* operator -> () const {
        return (arrayKlass*)obj()->klass_part();
    }
    static arrayKlassHandle cast(KlassHandle h) {
        return arrayKlassHandle(h());
    }
};

class typeArrayKlassHandle : public KlassHandle {
public: 
    typeArrayKlassHandle() : KlassHandle() {
    }
    typeArrayKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArray_slow(), "illegal type");
    }
    typeArrayKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArray_slow(), "illegal type");
    }
    typeArrayKlass* operator -> () const {
        return (typeArrayKlass*)obj()->klass_part();
    }
    static typeArrayKlassHandle cast(KlassHandle h) {
        return typeArrayKlassHandle(h());
    }
};

class objArrayKlassHandle : public KlassHandle {
public:
    objArrayKlassHandle() : KlassHandle() {
    }
    objArrayKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArray_slow(), "illegal type");
    }
    objArrayKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArray_slow(), "illegal type");
    }
    objArrayKlass* operator -> () const {
        return (objArrayKlass*)obj()->klass_part();
    }
    static objArrayKlassHandle cast(KlassHandle h) {
        return objArrayKlassHandle(h());
    }
};

class constantPoolKlassHandle : public KlassHandle {
public: 
    constantPoolKlassHandle() : KlassHandle() {
    }
    constantPoolKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolKlass* operator -> () const {
        return (constantPoolKlass*)obj()->klass_part();
    }
    static constantPoolKlassHandle cast(KlassHandle h) {
        return constantPoolKlassHandle(h());
    }
};

class constantPoolCacheKlassHandle : public KlassHandle {
public: 
    constantPoolCacheKlassHandle() : KlassHandle() {
    }
    constantPoolCacheKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolCacheKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolCacheKlass* operator -> () const {
        return (constantPoolCacheKlass*)obj()->klass_part();
    }
    static constantPoolCacheKlassHandle cast(KlassHandle h) {
        return constantPoolCacheKlassHandle(h());
    }
};

InvalidArchiveError ARNING conda.gateways.disk.delete:unlink_or_rename_to_trash(143): Could not rem
caigen0001的专栏
10-24 4107
InvalidArchiveError ARNING conda.gateways.disk.delete:unlink_or_rename_to_trash(143): Could not remove or rename
selenium.common.exceptions.WebDriverException: Message: no such session报错
qq_43396677的博客
01-04 2376
附上代码： import json import time import pandas as pd import os from bs4 import BeautifulSoup from pyecharts import Bar,Line,Overlap from selenium import webdriver os.chdir('D:/爬虫/综艺') driver = webdrive...
nstanceKlass对象
weixin_54509877的博客
01-20 425
oop java_lang_Class::create_mirror(KlassHandle k, Handle protection_domain, TRAPS) { assert(k->java_mirror() == NULL, “should only assign mirror once”); // … // Class_klass has to be loaded because it is used to allocate the mirror. ////////////////////
描述一个Java类型：oop、klass和handle类
大力海棠的博客
08-17 1160
目录 虚函数列表 opp、klass和handle类型 oop体系 klass体系 handle类 现在使用广泛的hotspot虚拟机里，使用opp-klass模型，分两部分来表示Java类和对象，oop也就是ordinary object pointer，普通对象指针，用来标识对象的实例，klass则是用来描述类，标识里面的变量和方法等。oop体系和klass体系中都有instance、method、constantMethod和methodData等结构，大家共同组合起来一起描述...
Handle/body模式
智能网联汽车V2X开发网的博客
05-10 918
一直挺火的模式， 也称呼为桥接模式，记录一下： Handle/body(桥接模式)，handle 只有接口，body（handleImpl ）是具体的实现。 handle 都不会变，要变的只有handleImpl ，被称为编译防火墙，这样有一层handle的接口，只需要改动impl，并且改动Impl的时候，不用额外编译handle.cpp。 另外一个好处主要是，用户不用包含那么多头文件，省的知道的接口太多，不好用。比如main只需要包含一个handle.hpp。 例如： handle 类： hpp: cla
HotSpot的Java对象模型：Oop-Klass模型
suming97的博客
08-18 830
在JVM层面，不仅Java类是对象，Java 方法也是对象， 字节码常量池也是对象，一切皆是对象。JVM使用不同的oop-klass模型来表示各种不同的对象。
JVM篇-oop-klass模型对类的描叙及类加载&实例化内存申请过程
Feverasa的博客
03-07 822
一、oop-klass描叙 1、介绍 ​ 在JVM内存用到了oop-klass模型来描叙对应的类及对象：oop(ordinary object ponter，普通对象指针)，其是用来描叙对象的实例信息。klass，其是JVM内部用来描叙类的信息的，例如Java类的继承信息，成员方法等信息。同时JVM还有一种类型来封装对oop类型的行为-handle。 2、handle class Handle VALUE_OBJ_CLASS_SPEC { private: oop* _handle; prote
GUI_handles.zip_GUI_handles_GUI_handles.zip _MATLAB GUI源代码_Matla
09-24
"GUI_handles.zip"是一个包含MATLAB GUI源代码的压缩包，特别针对"handles"这一主题，旨在帮助用户深入理解并熟练掌握MATLAB GUI的编写。 在MATLAB GUI中，"handles"是一个关键概念，它是一种数据结构，存储了GUI...
 pycharm 启动报错：Caused by: java.lang.IllegalAccessException: symbolic reference class is not accessibl
shunzi2016的博客
04-11 3636
pycharm 启动报错 Internal error. Please refer to http://jb.gg/ide/critical-startup-errors java.util.concurrent.CompletionException: java.lang.IllegalStateException: An unexpected core classloader: cla...
驱动版本ok，python中遇到“selenium.common.exceptions.WebDriverException: Message: ‘chromedriver‘ ”的解决方法
weixin_46662419的博客
09-30 2261
一、问题现象 运行testDemo.py，报 selenium.common.exceptions.WebDriverException: Message: ‘chromedriver’ executable needs to be in PATH. Please see https://sites.google.com/a/chromium.org/chromedriver/home 二：testDemo.py内容 from selenium import webdriver import time
Java类加载之Class对象到Klass模型
weixin_37152234的博客
03-07 1528
这是没啥用的知识第一篇技术文章，澜叔准备聊一聊Java中的类加载机制。在写Java程序的时候，你不用知道类加载机制是啥，它从哪里来，要到哪里去，虽然这知识没啥用 ，但是，面试(吹水)或许能顶一顶。 每一个Java程序员在刚开始学Java的时候，第一个了解到的，一定是Java的灵魂——JVM。你写的JavaBug，I‘M sorry，Java代码最终一定是经过Java编译器编译成class文件后，交付给JVM进行逻辑执行。 那么你一定一定要疑惑(否则写不下去了)，Java类是如何与JVM进行交互的呢.
java 类 自指属性_第五章 常量池解析
weixin_35460054的博客
02-16 358
常量池解析Java字节码常量池的内存分配链路oop-klass模型常量池的解析原理在字节码文件中，常量池的字节码流所在的块区紧跟在魔数和版本号之后，因此JVM在解析完魔数与版本号后就开始解析常量池。JVM解析Java类字节码文件的接口：ClassFileParser::parseClassFile(),总体步骤如下：解析魔数–>解析版本号–>解析常量池–>解析父类–>解析接...
深入OpenJDK源码全面理解Java类加载器（上 -- JVM源码篇）
热门推荐
黄智霖的博客
03-19 1万+
目录前言一、从JDK源码看双亲委派二、使用步骤1.引入库2.读入数据总结 前言 关于JVM类加载的基础理论知识，请参照《深入理解Java虚拟机》读书笔记（六）–虚拟机类加载机制（上）和《深入理解Java虚拟机》读书笔记（六）–虚拟机类加载机制（下）。 一、从JDK源码看双亲委派 注：博主是使用的是openjdk8，换了新电脑还没有去编译源码，所以看的是静态代码，关于如何编译和调试源码，网上不少文章都有介绍，这里就不赘述了 我们都知道在Java类加载中，除了BootStrap加载器，App和Ext加载
oop-klass内存模型
qq_26000415的博客
03-01 1万+
只要是对JVM有所了解的,或多或少的都知道oop-klass模型.那么什么是oop-klass模型? JVM内部基于oop-klass模型描述一个java类,将一个java类分为两个部分进行描述,其中第一个模型是oop,第二个模型是klass. 接下来,本文从以下几个角度进行讲解: 宏观: 从整体上描述一下oop-klass模型 微观: 从类的继承结构上进行讲述,加深理解 宏观 JVM使用...
jvm源码分析之oop-klass对象模型
lzf的博客
08-01 2157
概述 HotSpot是基于c++实现，而c++是一门面向对象的语言，本身具备面向对象基本特征，所以Java中的对象表示，最简单的做法是为每个Java类生成一个c++类与之对应。 但HotSpot JVM并没有这么做，而是设计了一个OOP-Klass Model。这里的 OOP 指的是 Ordinary Object Pointer （普通对象指针），它用来表示对象的实例信息，看起来像个指针实际...
HotSpotVM JNI 实现浅析
Just for Fun la
03-13 2577
最近想看下HotSpotVM是怎么找到一个native方法的实现的，例如Thread.start0和FileChannelImpl.transferTo0，最后发现是两种不同的方式。
源码分析：Java对象的内存分配
weixin_34125592的博客
11-16 172
　　Java对象的分配，根据其过程，将其分为快速分配和慢速分配两种形式，其中快速分配使用无锁的指针碰撞技术在新生代的Eden区上进行分配，而慢速分配根据堆的实现方式、GC的实现方式、代的实现方式不同而具有不同的分配调用层次。下面就以bytecodeInterpreter解释器对于new指令的解释出发，分析实例对象的内存分配过程： 　一、快速分配 　 1.实例的创建首先需要知道该类型是否被加载...
第五章 常量池解析
li1376417539的博客
10-03 911
常量池解析 Java字节码常量池的内存分配链路 oop-klass模型 常量池的解析原理 在字节码文件中，常量池的字节码流所在的块区紧跟在魔数和版本号之后，因此JVM在解析完魔数与版本号后就开始解析常量池。JVM解析Java类字节码文件的接口：ClassFileParser::parseClassFile(),总体步骤如下：解析魔数–>解析版本号–>解析常量池–>解析父类–...
远程系统管理Web服务器 允许本地或远程客户通过HTTP协议访问系统信息，例如显示时间、Linux发布版本、空闲磁盘空间、当前运行的进程等 使用模块架构针对Web请求生成动态HTML网页；各模块实现为共享目标库，允许动态装载模块，且可在服务器运行期间添加、删除和替换 在子进程或线程中服务Web请求，并设计进程池或线程池管理这些进程或线程 服务器不要求超级用户权限 不要求实现HTTP全部功能 使用面向对象架构 程序架构 server.h：可导出的全局变量、全局类型和函数的声明 common.cpp：通用函数的定义 module.cpp：服务模块的装载与卸载功能的实现 server.cpp：服务器功能的实现 main.cpp：主函数 服务模块 time.h：显示系统时间 issue.cpp：显示系统发布信息 diskfree.cpp：显示空闲磁盘空间信息 process.cpp：显示服务器中当前运行的进程列表
最新发布
08-08
### ### 项目概述 在设计一个基于C++的远程系统管理Web服务器时，可以采用面向对象的架构和模块化设计，结合进程池或线程池来高效处理HTTP请求。该服务器应具备以下核心功能： - **动态HTML生成**：支持根据请求动态生成HTML内容。 - **共享库模块热插拔**：允许在不重启服务器的情况下动态加载和卸载模块。 - **进程池/线程池管理**：通过池化技术提升并发处理能力。 - **无需超级用户权限**：支持在普通用户权限下运行。 ### ### 模块化架构设计 模块化架构的核心是将功能划分为独立的模块，每个模块通过统一的接口与核心系统交互。可以使用 **共享库（.so 文件）** 实现模块的热插拔功能。模块接口定义如下： ```cpp // module_interface.h class ModuleInterface { public: virtual ~ModuleInterface() {} virtual void handleRequest(const std::string& path, std::string& response) = 0; }; ``` 模块实现示例： ```cpp // example_module.cpp #include "module_interface.h" #include <string> class ExampleModule : public ModuleInterface { public: void handleRequest(const std::string& path, std::string& response) override { response = "<html><body><h1>Hello from module: " + path + "</h1></body></html>"; } }; extern "C" ModuleInterface* create_module() { return new ExampleModule(); } ``` 编译共享库： ```bash g++ -shared -fPIC example_module.cpp -o libexample_module.so ``` ### ### 动态模块加载器 动态加载器负责在运行时加载共享库并调用模块接口： ```cpp #include <dlfcn.h> #include <string> #include <unordered_map> class ModuleLoader { public: ModuleInterface* loadModule(const std::string& path) { void* handle = dlopen(path.c_str(), RTLD_LAZY); if (!handle) { return nullptr; } ModuleInterface* (*create)() = reinterpret_cast<ModuleInterface* (*)()>(dlsym(handle, "create_module")); if (!create) { dlclose(handle); return nullptr; } ModuleInterface* module = create(); modules_[path] = module; handles_[path] = handle; return module; } void unloadModule(const std::string& path) { if (modules_.find(path) != modules_.end()) { delete modules_[path]; dlclose(handles_[path]); modules_.erase(path); handles_.erase(path); } } private: std::unordered_map<std::string, ModuleInterface*> modules_; std::unordered_map<std::string, void*> handles_; }; ``` ### ### 进程池实现 进程池用于处理HTTP请求，提升并发性能。以下是一个简单的进程池实现： ```cpp #include <vector> #include <functional> #include <unistd.h> #include <sys/wait.h> template <size_t NumProcesses> class ProcessPool { public: using Task = std::function<void()>; ProcessPool() { for (size_t i = 0; i < NumProcesses; ++i) { pid_t pid = fork(); if (pid == 0) { while (true) { // 子进程等待任务 } exit(0); } else if (pid > 0) { pids_.push_back(pid); } else { // 错误处理 } } } void submit(Task task) { tasks_.push(task); } void run() { while (true) { if (!tasks_.empty()) { Task task = tasks_.front(); tasks_.pop(); task(); } } } private: std::vector<pid_t> pids_; std::queue<Task> tasks_; }; ``` ### ### HTTP请求处理 使用 **Boost.Beast** 或 **Poco** 等网络库实现HTTP服务器。以下是一个使用Boost.Beast的简化示例： ```cpp #include <boost/beast/core.hpp> #include <boost/beast/websocket.hpp> #include <boost/asio/ip/tcp.hpp> #include <string> namespace beast = boost::beast; namespace websocket = beast::websocket; namespace net = boost::asio; using tcp = net::ip::tcp; void handleSession(tcp::socket socket) { websocket::stream<tcp::socket> ws(std::move(socket)); ws.accept(); for (;;) { beast::flat_buffer buffer; ws.read(buffer); std::string message = beast::make_print_string(buffer.data()); std::string response = "Server received: " + message; ws.write(net::buffer(response)); } } ``` ### ### 无需超级用户权限运行 为了在非特权端口（如8080）运行Web服务器，只需绑定到非特权端口即可。例如： ```cpp net::io_context ioc; tcp::acceptor acceptor(ioc, {tcp::v4(), 8080}); ``` ### ### 综合架构 将模块加载器、进程池和HTTP服务器结合，形成完整的系统： ```cpp int main() { ModuleLoader loader; ProcessPool<4> pool; loader.loadModule("libexample_module.so"); // 启动HTTP服务器并分发任务到进程池 net::io_context ioc; tcp::acceptor acceptor(ioc, {tcp::v4(), 8080}); for (;;) { tcp::socket socket(ioc); acceptor.accept(socket); pool.submit([socket = std::move(socket)]() mutable { handleSession(std::move(socket)); }); } return 0; } ``` ###
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值