JVM之线程资源标记ResourceMark

Hotspot 方法调用之StubRoutines 源码解析 目录 一、StubRoutines 1、定义 2、initialize1和initialize2方法 二、ResourceMark 1、ResourceArea 2、构造和析构函数 三、BufferBlob 四、CodeBlob 1、定义 2、构造和flush方法 五、CodeBuffer 1、定义 2、构造和析构方法 3、copy_code_and_locs... 阅读详情

在前面介绍JVM的类加载中比如Field和Method的解析之前,都时要县创建一个ResourceMark对象,那么我们今天介绍下ResourceMark这个类。

ResourceMark类的主要成员以及方法

  1. ResourceMark继承StackObj,表示它是分配在栈上的, 它内部持有 ResourceMarkImpl实现类的引用.在构造函数中,会初始化ResourceMarkImpl类的构造方法传入当前线程的ResouceArea对象。
    class ResourceMark: public StackObj {
      const ResourceMarkImpl _impl;
      // 构造方法
      ResourceMark(ResourceArea* area, Thread* thread) :
        _impl(area),
        _thread(thread),
        _previous_resource_mark(nullptr)
      {
        if (_thread != nullptr) {
          assert(_thread == Thread::current(), "not the current thread");
          _previous_resource_mark = _thread->current_resource_mark();
          _thread->set_current_resource_mark(this);
        }
      }
    public:
      ResourceMark() : ResourceMark(Thread::current()) {}
      explicit ResourceMark(Thread* thread)
        : ResourceMark(thread->resource_area(), thread) {}
      explicit ResourceMark(ResourceArea* area)
        : ResourceMark(area, DEBUG_ONLY(Thread::current_or_null()) NOT_DEBUG(nullptr)) {}
    
      void reset_to_mark() { _impl.reset_to_mark(); }
    };

    ResourceMark的实现类ResourceMarkImpl构造函数和方法

  2. 构造函数传入当前线程的ResourceArea对象,保存到_area变量。 并调用SavedState构造函数初始化_saved_state变量。 然后再函数体重调用ResourceArea的activate_state校验当前资源状态,并且将_nesting变量加1。
    class ResourceMarkImpl {
      ResourceArea* _area;   
      ResourceArea::SavedState _saved_state; // ResourceArea的快照
      
    public:
      explicit ResourceMarkImpl(ResourceArea* area) :
      _area(area),
      _saved_state(area)
      {
        _area->activate_state(_saved_state);
      }
      explicit ResourceMarkImpl(Thread* thread)
        : ResourceMarkImpl(thread->resource_area()) {}
    };

    SavedState是保存ResourceArea当前使用状态的快照。

    class SavedState {
        friend class ResourceArea;
        Chunk* _chunk;
        char* _hwm;
        char* _max;
        size_t _size_in_bytes;
    
      public:
        SavedState(ResourceArea* area) :
          _chunk(area->_chunk),
          _hwm(area->_hwm),
          _max(area->_max),
          _size_in_bytes(area->_size_in_bytes)
        {}
      };

    ResourceMarkImpl的析构函数

    在ResouceMark对象是在栈上分配,所以它在生命周期结束后,也会调用 ResourceMarkImpl的析构函数,从而调用reset_to_mark执行重置ResouceArea到分配内存空间之前的快照状态,然后调用deactivate_state将_nesting将1.

    ~ResourceMarkImpl() {
        reset_to_mark();
        _area->deactivate_state将(_saved_state);
      }
        void reset_to_mark() const {
        _area->rollback_to(_saved_state);
      }

    reset_to_mark调用reset_to_mark函数,最终通过调用ResourceArea的 rollback_to函数并传入之前保存的内存资源快照_saved_state。

  3. 首先判断UseMallocOnly是否只是用Malloc分配,如果是,则调用free_malloced_objects释放上一次分配的资源,这个默认是false,所以直接跳过。
  4. 如果快照状态中当前的Chunk的_next指针不为空指针,执行set_size_in_bytes重置到Area中总的Chunk的字节数,然后调用当前的next_chop函数
    void rollback_to(const SavedState& state) {
        assert(_nesting > state._nesting, "rollback to inactive mark");
        assert((_nesting - state._nesting) == 1, "rollback across another mark");
        if (UseMallocOnly) {
          free_malloced_objects(state._chunk, state._hwm, state._max, _hwm);
        }
        if (state._chunk->next() != nullptr) { 
          assert(size_in_bytes() > state._size_in_bytes,
                 "size: " SIZE_FORMAT ", saved size: " SIZE_FORMAT, size_in_bytes(), state._size_in_bytes);
          set_size_in_bytes(state._size_in_bytes);
          state._chunk->next_chop();
        } else {
          assert(size_in_bytes() == state._size_in_bytes, "Sanity check");
        }
        _chunk = state._chunk;      // Roll back to saved chunk.
        _hwm = state._hwm;
        _max = state._max;
    
        // Clear out this chunk (to detect allocation bugs)
        if (ZapResourceArea) {
          memset(state._hwm, badResourceValue, state._max - state._hwm);
        }
      }

    释放当前Chunk后面的Chunk资源

    next_chop调用chop释放当前Chunk的后面连接的Chunk的内存空间,可以是通过delete去释放空间.

    void Chunk::next_chop() {
      _next->chop();
      _next = NULL;
    }
    
    void Chunk::chop() {
      Chunk *k = this;
      while( k ) {
        Chunk *tmp = k->next();
        // 清除当前的Chunk的内存
        if (ZapResourceArea) memset(k->bottom(), badResourceValue, k->length());
        delete k;                   // Free chunk (was malloc'd)
        k = tmp;
      }
    }

分配内存资源管理器Arena

3.ResourceArea是继承Arena的资源管理器,ResourceMark是使用它去做内存资源分配。

class ResourceArea: public Arena {
  friend class VMStructs;

public:
  ResourceArea(MEMFLAGS flags = mtThread) :
    Arena(flags) DEBUG_ONLY(COMMA _nesting(0)) {}

  ResourceArea(size_t init_size, MEMFLAGS flags = mtThread) :
    Arena(flags, init_size) DEBUG_ONLY(COMMA _nesting(0)) {}

Arena类的主要Field

class Arena : public CHeapObj<mtNone> {
protected:
  MEMFLAGS    _flags;         // 追踪内存的标识
  Chunk *_first;             // 第一个分配的chunk
  Chunk *_chunk;             // 当前 chunk
  char *_hwm, *_max;        // 高水位 and 当前chunk的最大水位

 MEMFLAGS是内存种类的枚举,主要是以下几个内存存储的类别

define MEMORY_TYPES_DO(f)                                    
  f(mtJavaHeap,       "Java Heap")   // Java 堆            
  f(mtClass,          "Class")  // java的class对象             
  f(mtThread,         "Thread")   // 线程对象
  f(mtThreadStack,    "Thread Stack")
  f(mtCode,           "Code")      // 生成的字节码
  f(mtGC,             "GC")                                   
  f(mtGCCardSet,      "GCCardSet")   // G1使用的卡表 
  f(mtCompiler,       "Compiler")                             
  f(mtJVMCI,          "JVMCI")                                 
  f(mtInternal,       "Internal")         

 Chunk是分配内存资源管理者

Chunk是通过_next指针链接形成单向链表, _len记录当前Chunk的大小

class Chunk: CHeapObj<mtChunk> {
 private:
  Chunk*       _next;     // next指针指向下一个,形成链表
  const size_t _len;      //当前Chunk的大小
}

Arena构造函数初始化

  • Chunk继承了CHeapObj,它是重载new关键字,所以new Chunk就会再堆区分配对象并设置初始化大小为Chunk::init_size(从下面枚举可知初始大小为: 1k减去Chunk自身占用内存大小)。
  • 刚开始_first和_chunk变量是指向同一个chunk对象,_hwn初始化保存没有分配资源的位置. _max初始化为_hwn加当前chunk的大小len。
  • set_size_in_bytes设置可分配的字节数大小。
Arena::Arena(MEMFLAGS flag) : _flags(flag), _size_in_bytes(0) {
  _first = _chunk = new (AllocFailStrategy::EXIT_OOM, Chunk::init_size) Chunk(Chunk::init_size);
  _hwm = _chunk->bottom();   
  _max = _chunk->top();
  MemTracker::record_new_arena(flag);
  set_size_in_bytes(Chunk::init_size);
}

// 内存大小枚举
enum {
#ifdef _LP64
    slack      = 40,   // [RGV] Not sure if this is right, but make it a multiple of 8.
#else
    slack      = 24,  // suspected sizeof(Chunk) + internal malloc headers
#endif
    tiny_size  =  256  - slack, // Size of first chunk (tiny)
    init_size  =  1*K  - slack, // Size of first chunk (normal aka small)
    medium_size= 10*K  - slack, // Size of medium-sized chunk
    size       = 32*K  - slack, // Default size of an Arena chunk (following the first)
    non_pool_size = init_size + 32 // An initial size which is not one of above
  };

 

Arena分配内存资源

  • 首先是64位内存对齐
  • 然后调用internal_amalloc进行分配内存
void* Amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
    x = ARENA_ALIGN(x); // 64位内初对齐
    // 校验内存对齐
    assert(is_aligned(_max, ARENA_AMALLOC_ALIGNMENT), "chunk end unaligned?");
    return internal_amalloc(x, alloc_failmode);
  }

 

  • 调用pointer_delta计算当前Chunk是有剩余的空间分配申请的x字节,则直接 _hwm 加上x,返回这次分配的_hwm指针。
  • 如果当前Chunk没有足够的剩余空间,则调用grow进行创建新的Chunk的进行分配内存空间。
void* internal_amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM)  {
    assert(is_aligned(x, BytesPerWord), "misaligned size");
    if (pointer_delta(_max, _hwm, 1) >= x) {
      char *old = _hwm;
      _hwm += x;
      return old;
    } else {
      return grow(x, alloc_failmode);
    }
  }

 分配新的Chunk分配内存空间,空间大小取申请的x的64位对齐和Chunk::size(实际大小是32k-Chunk对象自身占用大小)

void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
  size_t len = MAX2(ARENA_ALIGN(x), (size_t) Chunk::size);

  Chunk *k = _chunk;        //记录之前的Chunk
  _chunk = new (alloc_failmode, len) Chunk(len);

  if (_chunk == NULL) {
    _chunk = k;  // 创建 Chunk失败,则恢复之前的Chunk指针
    return NULL;
  }
  if (k) k->set_next(_chunk);   // 将新的chunk设置_next指针
  else _first = _chunk;
  _hwm  = _chunk->bottom(); //保存chunk的最小地址
  _max =  _chunk->top();  // 保存chunk的最大地址
  set_size_in_bytes(size_in_bytes() + len);//设置Arena的所有Chunk的总的字节大小
  void* result = _hwm; // 返回Chunk开始分配的内存的void*指针
  _hwm += x; // 将_hwm加上x,那么就分配了[_hwn,_hwn+x]内存空间,返回result指针指向_hwn加x之前的地址指针
  return result;
}

Arena的分配内存是Chunk的链表组成

总结

本文主要分析栈上分配的ResouceMark,利用线程的ResourceArea进行分配前的快照保存以及内存分配,并利息ResourceMarkImpl的析构函数,释放当前Chunk后面分配的内存空间,并恢复分配前的内存快照的状态,

 

JVM 调优之 glibc 引发的内存泄露 malloc ? 这是申请内存的函数啊,为什么要申请这么多呢?难道没有释放? 于是想到用 pmap 命令看一下内存映射情况。 Pmap 提供了进程的内存映射,pmap 命令用于显示一个或多个进程的内存状态。其报告进程的地址空间和内存状态信息 执行了以下命令: pmap -x 1 | sort -n -k3 复制代码 发现了一些端倪: 有一些 64M 左右的内存分配,且越来越多。 glibc 搞不懂了,于是 google 了一下。发现是有这一类问题由于涉及许多底层基础知识,这里就大概解析一下,有兴趣的读 阅读详情

相关推荐

一个导致JVM物理内存消耗大的Bug

本文来自: PerfMa技术社区 PerfMa(笨马网络)官网 概述 最近我们公司在帮一个客户查一个JVM的问题(JDK1.8.0_191-b12),发现一个系统老是被OS Kill掉,是内存泄露导致的。在查的过程中,阴差阳错地发现了JVM另外的一个Bug。这个Bug可能会导致大量物理内存被使用,我们已经反馈给了社区,并得到快速反馈,预计在OpenJDK8最新版中发布(JDK11中也存在这个问题)。 PS:用户的那个问题最终也解决了,定位下来算是C2的一个设计缺陷导致大量内存被使用,安全性上没有得到保.

HeapDump性能社区的博客 2103

JVM篇-结合源码分析JVM堆内存&元空间的申请分配

一、堆内存的结构 1、结构图 ​ 我们可以看到官方给的这张图。可以看到其堆可以有两种分配类型:一种就是JVM申请提交的内存(committed)以及目前还没有使用到的内存(Virtual),另一种就是按照分代的概念:年轻代(Young Generation)老年代(Tenured Generation)。 ​ 同时根据这个结构图我们可以知道在代与代之间还有空出来暂时没有使用到的内存。 2、年轻代&老年代分配 ​ 我们可以看到在年轻代是有两个概念的划分的:Eden、Survivor,然后Surviv

Feverasa的博客 1392

Netty源码之arena、chunk、page、subpage概念

在本节我们将梳理一下有关内存分配几个非常重要的概念,分别是arena、chunk、page、subpage。 接下来我们看一下什么是arena: 在每个线程去申请内存的时候,他首先会通过ThreadLocal这种方式去获得当前线程的PoolThreadCache对象,然后调用他的allocate方法去申请内存,他一共分为两部分,一个是cache,在申请内存的时候首先会尝试从缓存中获取,另外一个就...

m0_37343985的博客 1238

Hotspot源码解析-第25章-类的初始化

Hotspot源码解析;JVM源码解析;JVM类的初始化;Java虚拟机源码解析

zhang527294844的博客 676

JVM 系列一:Native memory allocation 导致JVM Crash

JVM Crash抛出如下信息: # # There is insufficient memory for the Java Runtime Environment to continue. # Native memory allocation (malloc) failed to allocate 813056 bytes for Chunk::new # An error report fi

Kylin Soong Blog -> ksoong.org 6万+

【愚公系列】《AIGC辅助软件开发》041-如何使用 AI技术提升工作效率:AI辅助软件架构师实践

在数字化转型的浪潮中,软件架构师作为技术团队的核心,承载着系统设计与架构优化的重要责任。然而,随着项目复杂度的增加和技术环境的变化,架构师面临着前所未有的挑战。幸运的是,人工智能(AI)技术的迅猛发展为这一行业带来了新的机遇,帮助架构师提升工作效率、优化决策过程,并改善团队协作。本文将深入探讨AI如何辅助软件架构师的实际工作,具体分析AI在需求分析、架构设计、代码生成、测试和优化等环节的应用。

愚公智库 15万+

Idea中Mark as为Sources和Resources的区别

1.Sources存放工程的源代码;Resources存放工程的资源文件,例如properties/XML等文件 2.个人的理解是,凡是被Mark as为Sources和Resources下面的代码或者文件可以被Idea自动编译,编译后都放在target/classes文件下面。classpath就是指的classes这个文件下面的资源

zhangustb 1万+

【转载】参数估计(Parameter Estimation):频率学派(最大似然估计MLE、最大后验估计MAP)与贝叶斯学派(贝叶斯估计BPE)

基础 频率学派与贝叶斯学派 http://www.douban.com/group/topic/16719644/ http://www.zhihu.com/question/20587681 最大似然估计(Maximum likelihood estimation,MLE) http://baike.baidu.com/view/1918804.htm http://baike.baidu.co

影 的专栏 3413

GenCollectedHeap的Gc策略MarkSweepPolicy

当内存堆管理器响应应用线程的一次内存分配请求失败时(就是没有足够的空闲内存),就会触发一次Gc来回收部分或所有的垃圾对象好腾出足够的空间来满足应用的所需内存,如果还不够则抛出OOM. MarkSweepPolicy的大体思路就是标记active的对象, 清理未被标记(非active)的对象MarkSweepPolicy作为内存堆管理器GenCollectedHeap的默认配置Gc策略, 针对这种内

xhh198781的专栏 2847

视频教程-SAP S4 HANA FICO COPA 获利能力分析-ERP

SAP S4 HANA FICO COPA 获利能力分析 从业超过8年的SA...

weixin_33456805的博客 1444

Proteus 8.9仿真五路抢答器:从74LS148编码到NE555报警的保姆级电路拆解

本文详细解析了使用Proteus 8.9仿真五路抢答器的完整设计流程,从74LS148优先编码器到NE555定时报警电路。通过保姆级的电路拆解和芯片选型指南,帮助读者掌握数字电路中的编码、锁存、译码和定时等核心技术,实现稳定可靠的抢答系统仿真。

weixin_30836759的博客 382

java线程锁标记_Java多线程(一)——基础概念/Thread/锁/AQS

AQS是什么:java.util.concurrnt包中lock包下有一个抽象类:AbstractQueuedSynchronizer简称为AQS。为实现阻塞锁和相关同步器提供一个框架,他是依赖于先进先出的等待队列。依靠单个原子int值来表示状态,该状态用于表示锁是获取中还是释放。通过给定的方法改变状态的值。定义了内部类ConditionObject拥有两种线程模式独占模式共享模式在LOCK包中的...

weixin_36054159的博客 344

11种图像清晰度评价函数附MATLAB代码

博主的第一篇博客! 本科毕业论文是“基于图像处理的自动对焦技术研究”,对焦过程中的一个重要阶段是图像清晰度评价,博主自己用MATLAB实现了4类清晰度评价函数:基于图像梯度的清晰度评价函数、频域评价函数、信息熵评价函数、统计学评价函数,总计11种。博主之前没有用过MATLAB,完全是本科论文需要,没办法对着别人的代...

kungfu_rabbit的博客 5万+

jvm疯狂吞占内存,罪魁祸首是谁

分享一篇公司小伙伴的关于jvm占用内存的技术文章 导读:JVM是Java Virtual Machine的缩写,中文名为Java虚拟机。它是一种用于计算设备的规范,是一个虚构出来的计算机,主要通过在实际的计算机上仿真模拟各种计算机功能来实现的。在实际运用过程中,易观技术人员注意到一台开发机上各个微服务进程占用内存很高,随即便展开了调查...... 现象:前段时间发现某台开发机上各个微服务进程占...

数据之路 1万+

行列式详解:从定义到应用

本文系统介绍了行列式的核心概念和应用。首先从二阶、三阶行列式入手,逐步扩展到n阶行列式的定义,讲解了余子式和代数余子式的概念。其次,详细阐述了行列式的重要性质,包括转置不变性、行列交换变号等基本性质以及乘积性质等推论。在计算方法方面,介绍了按行展开法、化上三角矩阵法等实用技巧,并列举了特殊行列式的计算案例。最后重点讨论了行列式在克拉默法则、矩阵可逆性判断、几何体积计算及线性相关性判断等领域的应用。文章强调理解行列式的几何意义和灵活运用性质的重要性,并给出了学习建议和常见误区提示。行列式作为连接代数与几何的桥

aichitang2024的博客 3039

【数字孪生与仿真技术】10:半导体制造中的虚拟量测技术深度解析:从多尺度建模到工业级应用

摘要:半导体制造过程中,晶圆加工需实时监测300+关键参数,传统物理量测技术面临产能损耗、延迟检测等痛点。本文系统阐述虚拟量测(Virtual Metrology)技术的完整解决方案,通过多尺度混合建模实现物理机理与数据驱动的深度融合。内容涵盖等离子体刻蚀、薄膜沉积等关键工艺的物理模型构建,LSTM神经网络的数据校正算法,以及边缘-云协同的实时部署架构。某12英寸晶圆厂实践表明,虚拟量测技术可减少70%物理量测频次,异常漏检率从18%降至3%,机台利用率提升11%。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 2560

第04篇:Resources资源文件处理,再也不怕找不到文件了。

Java 的java.net.URL各种 URL 前缀的标准类和标准处理程序不足以满足所有对低级资源的访问。例如,没有URL可用于访问需要从类路径或相对ServletContext。于是乎这就给了Spring,封装继承多态,大展身手的展示了。怎么展示呢?在Spring中就是Resource接口,下面我们就看看Resource。我们利用Spring提供的能力,可以获取任何你想获取的文件,也可以使用通配符来模糊查询你要的文件。下面开始展示。

西魏陶渊明的博客 2143

华为OD机试真题 C 实现【水库蓄水问题】【2022.11 Q4 新题】

给定一个长度为 n 的整数数组height。数组的元素表示山的高度,选择两个元素作为水库的边界,求蓄水量的最大值并输出蓄水量最大时的边界下标(蓄水量相同时输出下标较近的)。

MISAYAONE的博客 1万+

多线程的使用(二)

多线程

zyyy0的博客 620

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

JAVA问题定位大杂汇之java 虚拟机内存占用超出 -Xmx设置

最近一个同事遇到一个诡异的现象,jvm只分配了8G内存,可是通过top查看,该java进程占用了30G物理内存(该机最大内存32G)。该现象导致监控系统报警频繁并出现宕机。 同事让我看下这个问题,我一看打消了他的疑惑。这个是一个非堆溢出问题,java进程占用了很多非堆内存,没有释放. NIO是引起该类问题的凶手,Groovy也会导致类似问题出现。非堆内存溢出,用jvm提供工具,是没有办法定位的。

nature502的专栏 1万+

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

当Java虚拟机遇上Linux Arena内存池

故障案例一 系统环境: RHEL 6.8 64-bit(glibc 2.12)、Sun JDK 6u45 64-bit、WLS 10.3.6 故障现象: 这里引用一下客户当时发邮件时提出的问题描述吧。 下面pid 6287 weblogic进程占用7.6G的物理内存,之前只占用5G内存。我发现只有系统有空余的内存,就会被java给吃掉,为什么内存占用越来越多? 通过

京庐空间 3115

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Hotspot 类文件加载、链接和初始化

在熟悉《class文件和字节码解析》和《Java对象内存表示机制》了之后,我们对类有了更进一步的认识,那么类文件是如何变成Hotspot中的Klass了? 加载器机制  《类加载机制》一文件中,我们已知道java加载器双亲委派机制,也知道调用loadClass方法可自定义加载类。不管我们在JAVA中通过JNI的方式(ClassLoader JNI接口的实现源码在jdk/src/share/nati...

懒猫的脚印 1022

Java程序在Linux上运行虚拟内存耗用很大

Java程序虚拟内存很大,到底是怎么引起的

杀花千万可染唇间一点·落红十里难掩眸中春意 2万+
上一篇: 【死磕JVM】用Arthas排查JVM内存 真爽!我从小用到大
下一篇: JVM之线程资源标记ResourceMark
java_lujj
博客等级 码龄4年 18粉丝 152原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值