欢迎光临
我们一直在努力

jvm运行时数据区

运行时数据区

学习目标

  • 深入理解JVM运行时数据区的完整结构和各区域的详细特点
  • 全面掌握程序计数器、虚拟机栈、本地方法栈的工作原理
  • 深入理解堆内存的分代模型和对象分配策略
  • 掌握方法区/元空间的演变历史和存储内容
  • 理解运行时常量池和字符串常量池的机制
  • 掌握栈帧的详细结构和执行过程
  • 能够分析和排查各种内存溢出问题
  • 理解直接内存的使用场景和注意事项

思维导图

#mermaid-svg-04Eiedlk0pC87elf{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-04Eiedlk0pC87elf .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-04Eiedlk0pC87elf .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-04Eiedlk0pC87elf .error-icon{fill:#552222;}#mermaid-svg-04Eiedlk0pC87elf .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-04Eiedlk0pC87elf .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-04Eiedlk0pC87elf .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-04Eiedlk0pC87elf .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-04Eiedlk0pC87elf .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-04Eiedlk0pC87elf .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-04Eiedlk0pC87elf .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-04Eiedlk0pC87elf .marker{fill:#333333;stroke:#333333;}#mermaid-svg-04Eiedlk0pC87elf .marker.cross{stroke:#333333;}#mermaid-svg-04Eiedlk0pC87elf svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-04Eiedlk0pC87elf p{margin:0;}#mermaid-svg-04Eiedlk0pC87elf .edge{stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .section–1 rect,#mermaid-svg-04Eiedlk0pC87elf .section–1 path,#mermaid-svg-04Eiedlk0pC87elf .section–1 circle,#mermaid-svg-04Eiedlk0pC87elf .section–1 polygon,#mermaid-svg-04Eiedlk0pC87elf .section–1 path{fill:hsl(240, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section–1 text{fill:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .node-icon–1{font-size:40px;color:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .section-edge–1{stroke:hsl(240, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth–1{stroke-width:17;}#mermaid-svg-04Eiedlk0pC87elf .section–1 line{stroke:hsl(60, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-0 rect,#mermaid-svg-04Eiedlk0pC87elf .section-0 path,#mermaid-svg-04Eiedlk0pC87elf .section-0 circle,#mermaid-svg-04Eiedlk0pC87elf .section-0 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-0 path{fill:hsl(60, 100%, 73.5294117647%);}#mermaid-svg-04Eiedlk0pC87elf .section-0 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-0{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-0{stroke:hsl(60, 100%, 73.5294117647%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-0{stroke-width:14;}#mermaid-svg-04Eiedlk0pC87elf .section-0 line{stroke:hsl(240, 100%, 83.5294117647%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-1 rect,#mermaid-svg-04Eiedlk0pC87elf .section-1 path,#mermaid-svg-04Eiedlk0pC87elf .section-1 circle,#mermaid-svg-04Eiedlk0pC87elf .section-1 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-1 path{fill:hsl(80, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-1 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-1{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-1{stroke:hsl(80, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-1{stroke-width:11;}#mermaid-svg-04Eiedlk0pC87elf .section-1 line{stroke:hsl(260, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-2 rect,#mermaid-svg-04Eiedlk0pC87elf .section-2 path,#mermaid-svg-04Eiedlk0pC87elf .section-2 circle,#mermaid-svg-04Eiedlk0pC87elf .section-2 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-2 path{fill:hsl(270, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-2 text{fill:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-2{font-size:40px;color:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-2{stroke:hsl(270, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-2{stroke-width:8;}#mermaid-svg-04Eiedlk0pC87elf .section-2 line{stroke:hsl(90, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-3 rect,#mermaid-svg-04Eiedlk0pC87elf .section-3 path,#mermaid-svg-04Eiedlk0pC87elf .section-3 circle,#mermaid-svg-04Eiedlk0pC87elf .section-3 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-3 path{fill:hsl(300, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-3 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-3{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-3{stroke:hsl(300, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-3{stroke-width:5;}#mermaid-svg-04Eiedlk0pC87elf .section-3 line{stroke:hsl(120, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-4 rect,#mermaid-svg-04Eiedlk0pC87elf .section-4 path,#mermaid-svg-04Eiedlk0pC87elf .section-4 circle,#mermaid-svg-04Eiedlk0pC87elf .section-4 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-4 path{fill:hsl(330, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-4 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-4{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-4{stroke:hsl(330, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-4{stroke-width:2;}#mermaid-svg-04Eiedlk0pC87elf .section-4 line{stroke:hsl(150, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-5 rect,#mermaid-svg-04Eiedlk0pC87elf .section-5 path,#mermaid-svg-04Eiedlk0pC87elf .section-5 circle,#mermaid-svg-04Eiedlk0pC87elf .section-5 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-5 path{fill:hsl(0, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-5 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-5{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-5{stroke:hsl(0, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-5{stroke-width:-1;}#mermaid-svg-04Eiedlk0pC87elf .section-5 line{stroke:hsl(180, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-6 rect,#mermaid-svg-04Eiedlk0pC87elf .section-6 path,#mermaid-svg-04Eiedlk0pC87elf .section-6 circle,#mermaid-svg-04Eiedlk0pC87elf .section-6 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-6 path{fill:hsl(30, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-6 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-6{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-6{stroke:hsl(30, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-6{stroke-width:-4;}#mermaid-svg-04Eiedlk0pC87elf .section-6 line{stroke:hsl(210, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-7 rect,#mermaid-svg-04Eiedlk0pC87elf .section-7 path,#mermaid-svg-04Eiedlk0pC87elf .section-7 circle,#mermaid-svg-04Eiedlk0pC87elf .section-7 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-7 path{fill:hsl(90, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-7 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-7{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-7{stroke:hsl(90, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-7{stroke-width:-7;}#mermaid-svg-04Eiedlk0pC87elf .section-7 line{stroke:hsl(270, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-8 rect,#mermaid-svg-04Eiedlk0pC87elf .section-8 path,#mermaid-svg-04Eiedlk0pC87elf .section-8 circle,#mermaid-svg-04Eiedlk0pC87elf .section-8 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-8 path{fill:hsl(150, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-8 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-8{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-8{stroke:hsl(150, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-8{stroke-width:-10;}#mermaid-svg-04Eiedlk0pC87elf .section-8 line{stroke:hsl(330, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-9 rect,#mermaid-svg-04Eiedlk0pC87elf .section-9 path,#mermaid-svg-04Eiedlk0pC87elf .section-9 circle,#mermaid-svg-04Eiedlk0pC87elf .section-9 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-9 path{fill:hsl(180, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-9 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-9{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-9{stroke:hsl(180, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-9{stroke-width:-13;}#mermaid-svg-04Eiedlk0pC87elf .section-9 line{stroke:hsl(0, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-10 rect,#mermaid-svg-04Eiedlk0pC87elf .section-10 path,#mermaid-svg-04Eiedlk0pC87elf .section-10 circle,#mermaid-svg-04Eiedlk0pC87elf .section-10 polygon,#mermaid-svg-04Eiedlk0pC87elf .section-10 path{fill:hsl(210, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-10 text{fill:black;}#mermaid-svg-04Eiedlk0pC87elf .node-icon-10{font-size:40px;color:black;}#mermaid-svg-04Eiedlk0pC87elf .section-edge-10{stroke:hsl(210, 100%, 76.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .edge-depth-10{stroke-width:-16;}#mermaid-svg-04Eiedlk0pC87elf .section-10 line{stroke:hsl(30, 100%, 86.2745098039%);stroke-width:3;}#mermaid-svg-04Eiedlk0pC87elf .disabled,#mermaid-svg-04Eiedlk0pC87elf .disabled circle,#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:lightgray;}#mermaid-svg-04Eiedlk0pC87elf .disabled text{fill:#efefef;}#mermaid-svg-04Eiedlk0pC87elf .section-root rect,#mermaid-svg-04Eiedlk0pC87elf .section-root path,#mermaid-svg-04Eiedlk0pC87elf .section-root circle,#mermaid-svg-04Eiedlk0pC87elf .section-root polygon{fill:hsl(240, 100%, 46.2745098039%);}#mermaid-svg-04Eiedlk0pC87elf .section-root text{fill:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .section-root span{color:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .section-2 span{color:#ffffff;}#mermaid-svg-04Eiedlk0pC87elf .icon-container{height:100%;display:flex;justify-content:center;align-items:center;}#mermaid-svg-04Eiedlk0pC87elf .edge{fill:none;}#mermaid-svg-04Eiedlk0pC87elf .mindmap-node-label{dy:1em;alignment-baseline:middle;text-anchor:middle;dominant-baseline:middle;text-align:center;}#mermaid-svg-04Eiedlk0pC87elf :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

运行时数据区

线程私有

程序计数器

虚拟机栈

本地方法栈

线程共享

堆

新生代

老年代

方法区

类信息

常量池

静态变量

其他

直接内存

一、运行时数据区概览

1.1 整体架构

/**
* JVM运行时数据区详解
*/

public class RuntimeDataAreas {

/**
* 运行时数据区的完整结构
*/

public static void overview() {
/*
* JVM运行时数据区分为两大类:
*
* 一、线程私有区域(每个线程独立):
* 1. 程序计数器(Program Counter Register)
* – 记录当前线程执行的字节码行号
* – 线程切换后能恢复到正确位置
* – 唯一不会OOM的区域
*
* 2. 虚拟机栈(Java Virtual Machine Stack)
* – 描述Java方法执行的内存模型
* – 每个方法执行时创建一个栈帧
* – 存储局部变量、操作数栈、动态链接、返回地址
*
* 3. 本地方法栈(Native Method Stack)
* – 为Native方法服务
* – HotSpot将其与虚拟机栈合并
*
* 二、线程共享区域(所有线程共享):
* 1. 堆(Heap)
* – 存储对象实例和数组
* – 垃圾回收的主要区域
* – 分为新生代和老年代
*
* 2. 方法区/元空间(Method Area/Metaspace)
* – 存储类信息、常量、静态变量、JIT编译后的代码
* – JDK 8之前:永久代(PermGen)
* – JDK 8之后:元空间(Metaspace)
*
* 三、其他:
* 1. 直接内存(Direct Memory)
* – 不属于JVM运行时数据区
* – NIO使用
*
* 内存结构图:
*
* ┌─────────────────────────────────────────────────────────┐
* │ 线程共享区域 │
* │ ┌─────────────────────────────────────────────────┐ │
* │ │ 堆(Heap) │ │
* │ │ ┌─────────────────────────────────────────┐ │ │
* │ │ │ 新生代(Young) │ │ │
* │ │ │ ┌────────┬──────────┬──────────┐ │ │ │
* │ │ │ │ Eden │Survivor 0│Survivor 1│ │ │ │
* │ │ │ │ (8) │ (1) │ (1) │ │ │ │
* │ │ │ └────────┴──────────┴──────────┘ │ │ │
* │ │ └─────────────────────────────────────────┘ │ │
* │ │ ┌─────────────────────────────────────────┐ │ │
* │ │ │ 老年代(Old) │ │ │
* │ │ └─────────────────────────────────────────┘ │ │
* │ └─────────────────────────────────────────────────┘ │
* │ ┌─────────────────────────────────────────────────┐ │
* │ │ 方法区/元空间 │ │
* │ │ – 类信息 │ │
* │ │ – 运行时常量池 │ │
* │ │ – 静态变量 │ │
* │ │ – JIT编译后的代码 │ │
* │ └─────────────────────────────────────────────────┘ │
* ├─────────────────────────────────────────────────────────┤
* │ 线程私有区域 │
* │ ┌──────────────┬──────────────┬──────────────────┐ │
* │ │ 程序计数器 │ 虚拟机栈 │ 本地方法栈 │ │
* │ │ (PC) │ (Stack) │ (Native Stack) │ │
* │ └──────────────┴──────────────┴──────────────────┘ │
* └─────────────────────────────────────────────────────────┘
*/

}

/**
* 各区域的特点对比
*/

public static void comparison() {
/*
* 特点对比表:
*
* | 区域 | 线程私有/共享 | 是否会OOM | 存储内容 |
* |————-|————–|———–|——————-|
* | 程序计数器 | 私有 | 否 | 字节码行号 |
* | 虚拟机栈 | 私有 | 是 | 栈帧 |
* | 本地方法栈 | 私有 | 是 | Native方法栈帧 |
* | 堆 | 共享 | 是 | 对象实例、数组 |
* | 方法区/元空间| 共享 | 是 | 类信息、常量、静态变量|
* | 直接内存 | – | 是 | 堆外内存 |
*
* 可能抛出的异常:
* – StackOverflowError:栈深度超过限制
* – OutOfMemoryError: Java heap space:堆内存不足
* – OutOfMemoryError: Metaspace:元空间不足
* – OutOfMemoryError: Direct buffer memory:直接内存不足
*/

}
}

二、程序计数器详解

2.1 程序计数器的作用

/**
* 程序计数器详解
*/

public class ProgramCounter {

/**
* 程序计数器的定义
*/

public static void definition() {
/*
* 程序计数器(Program Counter Register):
*
* 1. 定义
* – 一块较小的内存空间
* – 记录当前线程执行的字节码指令地址
* – 字节码解释器通过改变PC的值来选取下一条指令
*
* 2. 作用
* – 记录当前线程执行到哪一条字节码指令
* – 线程切换后能恢复到正确的执行位置
* – 分支、循环、跳转、异常处理、线程恢复都依赖PC
*
* 3. 特点
* – 线程私有:每个线程都有独立的PC
* – 占用内存很小:只存储一个地址
* – 唯一不会OOM的区域:不会抛出任何异常
* – 执行Java方法时:记录字节码指令地址
* – 执行Native方法时:值为Undefined(空)
*/

}

/**
* 程序计数器的工作原理
*/

public static void workingPrinciple() {
/*
* 工作原理示例:
*
* Java代码:
*/

int a = 1;
int b = 2;
int c = a + b;

/*
* 对应的字节码:
*
* 0: iconst_1 // PC = 0,将1压入操作数栈
* 1: istore_1 // PC = 1,存储到局部变量表slot 1
* 2: iconst_2 // PC = 2,将2压入操作数栈
* 3: istore_2 // PC = 3,存储到局部变量表slot 2
* 4: iload_1 // PC = 4,加载局部变量1
* 5: iload_2 // PC = 5,加载局部变量2
* 6: iadd // PC = 6,相加
* 7: istore_3 // PC = 7,存储结果
*
* 执行过程:
* 1. PC = 0,执行iconst_1
* 2. PC = 1,执行istore_1
* 3. PC = 2,执行iconst_2
* 4. PC = 3,执行istore_2
* 5. PC = 4,执行iload_1
* 6. PC = 5,执行iload_2
* 7. PC = 6,执行iadd
* 8. PC = 7,执行istore_3
*
* 线程切换:
* – 线程A执行到PC = 4时被挂起
* – 线程B开始执行
* – 线程A恢复时,从PC = 4继续执行
*/

}

/**
* 程序计数器与多线程
*/

public static void multiThreading() {
/*
* 多线程环境下的程序计数器:
*
* 1. 每个线程都有独立的PC
* – 线程1的PC:记录线程1的执行位置
* – 线程2的PC:记录线程2的执行位置
* – 互不干扰
*
* 2. 线程切换
* – CPU时间片用完,线程被挂起
* – 保存当前PC的值
* – 切换到另一个线程
* – 恢复该线程的PC值
* – 继续执行
*
* 3. 为什么需要线程私有的PC
* – 多线程并发执行
* – 每个线程执行不同的代码
* – 需要记录各自的执行位置
* – 线程切换后能恢复到正确位置
*
* 示例:
*/

// 线程1执行method1
Thread t1 = new Thread(() -> method1());

// 线程2执行method2
Thread t2 = new Thread(() -> method2());

t1.start();
t2.start();

/*
* 线程1的PC记录method1的执行位置
* 线程2的PC记录method2的执行位置
* 两者互不影响
*/

}

private static void method1() {
int x = 1;
int y = 2;
int z = x + y;
}

private static void method2() {
String s1 = "hello";
String s2 = "world";
String s3 = s1 + s2;
}
}

2.2 程序计数器的特殊性

/**
* 程序计数器的特殊性
*/

public class ProgramCounterSpeciality {

/**
* 为什么程序计数器不会OOM
*/

public static void noOOM() {
/*
* 程序计数器是唯一不会OOM的区域:
*
* 1. 占用内存极小
* – 只存储一个地址值
* – 通常是4字节或8字节
* – 不会随着程序运行而增长
*
* 2. 固定大小
* – 每个线程的PC大小固定
* – 不会动态分配
* – 不会扩展
*
* 3. 不存储对象
* – 只存储地址
* – 不会产生垃圾
* – 不需要GC
*
* 对比其他区域:
* – 堆:存储对象,会OOM
* – 栈:存储栈帧,会StackOverflow和OOM
* – 方法区:存储类信息,会OOM
* – PC:只存储地址,不会OOM
*/

}

/**
* Native方法的程序计数器
*/

public static void nativeMethod() {
/*
* 执行Native方法时,PC的值为Undefined:
*
* 1. Native方法不是Java字节码
* – 由C/C++实现
* – 没有字节码指令
* – PC无法记录字节码地址
*
* 2. Native方法的执行
* – 由本地方法栈管理
* – 不需要PC记录位置
* – PC值为空(Undefined)
*
* 3. 从Native方法返回
* – 恢复PC的值
* – 继续执行Java字节码
*
* 示例:
*/

// Java方法
int hash = calculateHash(); // PC记录字节码地址

// 调用Native方法
int systemHash = System.identityHashCode(new Object()); // PC为Undefined

// 返回Java方法
System.out.println(hash); // PC恢复,记录字节码地址
}

private static int calculateHash() {
return 123;
}
}

三、虚拟机栈详解

3.1 虚拟机栈的基本概念

/**
* 虚拟机栈详解
*/

public class JavaVirtualMachineStack {

/**
* 虚拟机栈的定义
*/

public static void definition() {
/*
* 虚拟机栈(Java Virtual Machine Stack):
*
* 1. 定义
* – 描述Java方法执行的内存模型
* – 每个方法执行时创建一个栈帧(Stack Frame)
* – 栈帧随着方法调用而入栈,方法返回而出栈
*
* 2. 特点
* – 线程私有:每个线程都有独立的虚拟机栈
* – 生命周期:与线程相同
* – 后进先出(LIFO):栈的特性
* – 存储:局部变量、操作数栈、动态链接、返回地址
*
* 3. 大小
* – 默认大小:Linux 1MB,Windows 320KB
* – 可通过-Xss参数设置
* – 例如:-Xss256k
*
* 4. 异常
* – StackOverflowError:栈深度超过限制
* – OutOfMemoryError:无法分配新的栈帧
*/

}

/**
* 虚拟机栈的工作原理
*/

public static void workingPrinciple() {
/*
* 工作原理示例:
*
* 方法调用链:main() -> method1() -> method2()
*
* 栈的变化过程:
*
* 1. main()方法开始执行
* ┌─────────────┐
* │ main() │
* └─────────────┘
*
* 2. main()调用method1()
* ┌─────────────┐
* │ method1() │
* ├─────────────┤
* │ main() │
* └─────────────┘
*
* 3. method1()调用method2()
* ┌─────────────┐
* │ method2() │
* ├─────────────┤
* │ method1() │
* ├─────────────┤
* │ main() │
* └─────────────┘
*
* 4. method2()执行完毕,出栈
* ┌─────────────┐
* │ method1() │
* ├─────────────┤
* │ main() │
* └─────────────┘
*
* 5. method1()执行完毕,出栈
* ┌─────────────┐
* │ main() │
* └─────────────┘
*
* 6. main()执行完毕,出栈
* (栈为空)
*/

}

/**
* 方法调用示例
*/

public static void example() {
System.out.println("main开始");
method1();
System.out.println("main结束");
}

private static void method1() {
System.out.println("method1开始");
method2();
System.out.println("method1结束");
}

private static void method2() {
System.out.println("method2开始");
System.out.println("method2结束");
}
}

3.2 栈帧结构详解

/**
* 栈帧结构详解
*/

public class StackFrame {

/**
* 栈帧的完整结构
*/

public static void structure() {
/*
* 栈帧(Stack Frame)的结构:
*
* ┌─────────────────────────────────────────┐
* │ 栈帧(Stack Frame) │
* ├─────────────────────────────────────────┤
* │ 1. 局部变量表(Local Variables) │
* │ – 存储方法参数和局部变量 │
* │ – 以Slot为单位 │
* │ – 基本类型和引用类型 │
* ├─────────────────────────────────────────┤
* │ 2. 操作数栈(Operand Stack) │
* │ – 存储方法执行过程中的中间结果 │
* │ – 进行算术运算 │
* │ – 方法调用和返回 │
* ├─────────────────────────────────────────┤
* │ 3. 动态链接(Dynamic Linking) │
* │ – 指向运行时常量池的方法引用 │
* │ – 支持动态分派 │
* ├─────────────────────────────────────────┤
* │ 4. 返回地址(Return Address) │
* │ – 方法正常退出:调用者的PC │
* │ – 方法异常退出:异常处理器地址 │
* └─────────────────────────────────────────┘
*
* 栈帧的大小:
* – 编译期确定
* – 不同方法的栈帧大小不同
* – 取决于局部变量表和操作数栈的大小
*/

}
}

3.3 局部变量表详解

/**
* 局部变量表详解
*/

public class LocalVariableTable {

/**
* 局部变量表的结构
*/

public static void structure() {
/*
* 局部变量表(Local Variable Table):
*
* 1. 定义
* – 存储方法参数和局部变量
* – 以Slot(变量槽)为单位
* – 编译期确定大小
*
* 2. Slot的大小
* – 32位:4字节
* – 64位:8字节(但long和double占2个Slot)
*
* 3. 数据类型与Slot
* – boolean、byte、char、short、int、float、reference:1个Slot
* – long、double:2个Slot
*
* 4. Slot的复用
* – 局部变量作用域结束后,Slot可以被复用
* – 减少栈帧大小
*
* 5. Slot 0的特殊性
* – 实例方法:Slot 0存储this引用
* – 静态方法:Slot 0存储第一个参数
*/

}

/**
* 局部变量表示例
*/

public void instanceMethod(int a, String b) {
long c = 10L;
double d = 3.14;
Object e = new Object();

/*
* 局部变量表:
*
* Slot 0: this(实例方法的隐式参数)
* Slot 1: a (int,1个Slot)
* Slot 2: b (String引用,1个Slot)
* Slot 3-4: c (long,2个Slot)
* Slot 5-6: d (double,2个Slot)
* Slot 7: e (Object引用,1个Slot)
*
* 总共:8个Slot
*/

}

/**
* 静态方法的局部变量表
*/

public static void staticMethod(int a, String b) {
int c = 20;

/*
* 局部变量表:
*
* Slot 0: a (int,没有this)
* Slot 1: b (String引用)
* Slot 2: c (int)
*
* 总共:3个Slot
*/

}

/**
* Slot复用示例
*/

public static void slotReuse() {
{
int a = 1;
// a的作用域结束
}

int b = 2; // 复用a的Slot

/*
* 局部变量表:
*
* Slot 0: a(作用域内)
* Slot 0: b(复用a的Slot)
*
* 总共:1个Slot(复用)
*/

}

/**
* 局部变量表与GC
*/

public static void gcImpact() {
/*
* 局部变量表对GC的影响:
*
* 示例1:
*/

{
byte[] placeholder = new byte[64 * 1024 * 1024]; // 64MB
}
System.gc(); // placeholder仍然在局部变量表中,不会被回收

/*
* 示例2:
*/

{
byte[] placeholder = new byte[64 * 1024 * 1024]; // 64MB
}
int a = 0; // 复用placeholder的Slot
System.gc(); // placeholder可以被回收

/*
* 原因:
* – 局部变量表中的引用会阻止GC
* – Slot复用后,旧的引用被覆盖
* – 对象可以被回收
*/

}
}

3.4 操作数栈详解

/**
* 操作数栈详解
*/

public class OperandStack {

/**
* 操作数栈的定义
*/

public static void definition() {
/*
* 操作数栈(Operand Stack):
*
* 1. 定义
* – 后进先出(LIFO)的栈
* – 存储方法执行过程中的中间结果
* – 进行算术运算和方法调用
*
* 2. 特点
* – 编译期确定最大深度
* – 存储在Code属性的max_stack中
* – 32位数据类型占1个栈深度
* – 64位数据类型(long、double)占2个栈深度
*
* 3. 作用
* – 存储计算的中间结果
* – 作为计算过程中变量的临时存储空间
* – 方法调用时传递参数
* – 方法返回时传递返回值
*/

}

/**
* 操作数栈示例
*/

public static void example() {
/*
* Java代码:
*/

int a = 1;
int b = 2;
int c = a + b;

/*
* 字节码:
*
* 0: iconst_1 // 将常量1压入操作数栈
* 1: istore_1 // 从栈顶弹出,存入局部变量表slot 1
* 2: iconst_2 // 将常量2压入操作数栈
* 3: istore_2 // 从栈顶弹出,存入局部变量表slot 2
* 4: iload_1 // 从局部变量表slot 1加载到栈顶
* 5: iload_2 // 从局部变量表slot 2加载到栈顶
* 6: iadd // 栈顶两个int相加,结果压入栈顶
* 7: istore_3 // 从栈顶弹出,存入局部变量表slot 3
*
* 操作数栈的变化:
*
* 步骤1(iconst_1):
* 操作数栈:[1]
* 局部变量表:[]
*
* 步骤2(istore_1):
* 操作数栈:[]
* 局部变量表:[a=1]
*
* 步骤3(iconst_2):
* 操作数栈:[2]
* 局部变量表:[a=1]
*
* 步骤4(istore_2):
* 操作数栈:[]
* 局部变量表:[a=1, b=2]
*
* 步骤5(iload_1):
* 操作数栈:[1]
* 局部变量表:[a=1, b=2]
*
* 步骤6(iload_2):
* 操作数栈:[1, 2] // 栈顶是2
* 局部变量表:[a=1, b=2]
*
* 步骤7(iadd):
* 操作数栈:[3] // 1+2=3
* 局部变量表:[a=1, b=2]
*
* 步骤8(istore_3):
* 操作数栈:[]
* 局部变量表:[a=1, b=2, c=3]
*/

}

/**
* 复杂表达式的操作数栈
*/

public static void complexExpression() {
/*
* Java代码:
*/

int result = (1 + 2) * (3 + 4);

/*
* 字节码:
*
* 0: iconst_1 // [1]
* 1: iconst_2 // [1, 2]
* 2: iadd // [3]
* 3: iconst_3 // [3, 3]
* 4: iconst_4 // [3, 3, 4]
* 5: iadd // [3, 7]
* 6: imul // [21]
* 7: istore_1 // []
*
* 操作数栈的变化:
*
* iconst_1: [1]
* iconst_2: [1, 2]
* iadd: [3] // 1+2=3
* iconst_3: [3, 3]
* iconst_4: [3, 3, 4]
* iadd: [3, 7] // 3+4=7
* imul: [21] // 3*7=21
* istore_1: [] // 存储到局部变量表
*/

}

/**
* 方法调用的操作数栈
*/

public static void methodCall() {
/*
* Java代码:
*/

int result = add(10, 20);

/*
* 字节码:
*
* 0: bipush 10 // [10]
* 2: bipush 20 // [10, 20]
* 4: invokestatic // [],参数从栈中弹出,传递给add方法
* 7: istore_1 // [],返回值从栈中弹出,存储到局部变量表
*
* add方法的字节码:
*
* 0: iload_0 // [10],加载参数a
* 1: iload_1 // [10, 20],加载参数b
* 2: iadd // [30],相加
* 3: ireturn // [],返回值压入调用者的操作数栈
*/

}

private static int add(int a, int b) {
return a + b;
}
}

3.5 动态链接

/**
* 动态链接详解
*/

public class DynamicLinking {

/**
* 动态链接的定义
*/

public static void definition() {
/*
* 动态链接(Dynamic Linking):
*
* 1. 定义
* – 每个栈帧都包含一个指向运行时常量池的引用
* – 支持方法调用过程中的动态链接
*
* 2. 符号引用与直接引用
* – 符号引用:用符号描述引用的目标
* – 直接引用:直接指向目标的指针或偏移量
*
* 3. 静态解析与动态分派
* – 静态解析:编译期确定调用目标
* – 动态分派:运行时确定调用目标
*
* 4. 作用
* – 将符号引用转换为直接引用
* – 支持多态
* – 支持动态语言特性
*/

}

/**
* 动态链接示例
*/

public static void example() {
/*
* 示例:
*/

Animal animal = new Dog();
animal.makeSound(); // 动态分派

/*
* 字节码:
*
* invokevirtual #2 // 符号引用:Animal.makeSound()
*
* 运行时:
* 1. 通过动态链接找到运行时常量池中的符号引用
* 2. 解析为直接引用
* 3. 根据对象的实际类型(Dog)
* 4. 调用Dog.makeSound()
*
* 这就是多态的实现原理
*/

}
}

interface Animal {
void makeSound();
}

class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}

3.6 方法返回地址

/**
* 方法返回地址详解
*/

public class ReturnAddress {

/**
* 方法返回地址的定义
*/

public static void definition() {
/*
* 方法返回地址(Return Address):
*
* 1. 定义
* – 方法退出后需要返回到调用者的位置
* – 存储调用者的PC值
*
* 2. 方法退出的两种方式
* a. 正常退出(Normal Return)
* – 执行return指令
* – 返回地址:调用者的PC + 指令长度
* – 返回值(如果有)压入调用者的操作数栈
*
* b. 异常退出(Abrupt Return)
* – 抛出异常且未被捕获
* – 返回地址:异常处理器的地址
* – 通过异常表确定
* – 不会有返回值
*
* 3. 方法退出的过程
* – 恢复调用者的局部变量表和操作数栈
* – 将返回值压入调用者的操作数栈
* – 调整PC指向返回地址
*/

}

/**
* 正常返回示例
*/

public static void normalReturn() {
/*
* Java代码:
*/

int result = calculate(10);
System.out.println(result);

/*
* 字节码:
*
* 0: bipush 10
* 2: invokestatic #2 // 调用calculate方法
* 5: istore_1 // 返回地址:PC = 5
* 6: getstatic #3
* 9: iload_1
* 10: invokevirtual #4
*
* calculate方法返回时:
* 1. 将返回值压入调用者的操作数栈
* 2. PC = 5,继续执行istore_1
*/

}

/**
* 异常返回示例
*/

public static void abruptReturn() {
/*
* Java代码:
*/

try {
int result = divide(10, 0);
} catch (ArithmeticException e) {
System.out.println("除数不能为0");
}

/*
* divide方法抛出异常时:
* 1. 查找异常表
* 2. 找到匹配的异常处理器
* 3. PC跳转到异常处理器的地址
* 4. 不会有返回值
*/

}

private static int calculate(int n) {
return n * 2;
}

private static int divide(int a, int b) {
return a / b;
}
}

3.7 栈溢出

/**
* 栈溢出详解
*/

public class StackOverflow {

/**
* StackOverflowError的原因
*/

public static void causes() {
/*
* StackOverflowError的常见原因:
*
* 1. 无限递归
* – 递归没有终止条件
* – 递归深度过大
*
* 2. 方法调用链过长
* – 方法A调用方法B,B调用C,…
* – 调用链过长
*
* 3. 局部变量过多
* – 方法中定义大量局部变量
* – 栈帧过大
*
* 4. 栈大小设置过小
* – -Xss参数设置过小
*/

}

/**
* 无限递归示例
*/

public static void infiniteRecursion() {
/*
* 示例1:无终止条件的递归
*/

recursion();

/*
* 结果:
* Exception in thread "main" java.lang.StackOverflowError
* at StackOverflow.recursion(StackOverflow.java:xxx)
* at StackOverflow.recursion(StackOverflow.java:xxx)
* …
*
* 原因:
* – 每次递归调用都会创建新的栈帧
* – 栈帧不断入栈
* – 栈空间耗尽
* – 抛出StackOverflowError
*/

}

private static void recursion() {
recursion(); // 无限递归
}

/**
* 递归深度过大示例
*/

public static void deepRecursion() {
/*
* 示例2:递归深度过大
*/

factorial(100000);

/*
* 结果:
* Exception in thread "main" java.lang.StackOverflowError
*
* 原因:
* – 递归深度100000
* – 需要100000个栈帧
* – 超过栈的容量
*/

}

private static long factorial(int n) {
if (n == 0) {
return 1;
}
return n * factorial(n – 1);
}

/**
* 解决方案
*/

public static void solutions() {
/*
* 解决StackOverflowError的方法:
*
* 1. 修复递归逻辑
* – 添加终止条件
* – 减少递归深度
* – 改用循环
*
* 2. 增加栈大小
* – -Xss1m(增加到1MB)
* – -Xss2m(增加到2MB)
*
* 3. 使用尾递归优化
* – 某些语言支持尾递归优化
* – Java不支持,需要手动改写
*
* 4. 改用迭代
* – 将递归改为循环
* – 使用栈数据结构模拟递归
*/

// 示例:将递归改为循环
long result = factorialIterative(10);
}

private static long factorialIterative(int n) {
long result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
}

四、本地方法栈详解

4.1 本地方法栈的基本概念

/**
* 本地方法栈详解
*/

public class NativeMethodStack {

/**
* 本地方法栈的定义
*/

public static void definition() {
/*
* 本地方法栈(Native Method Stack):
*
* 1. 定义
* – 为Native方法服务的栈
* – Native方法:用C/C++等语言实现的方法
* – 通过JNI(Java Native Interface)调用
*
* 2. 特点
* – 线程私有
* – 与虚拟机栈类似
* – HotSpot虚拟机将其与虚拟机栈合并
*
* 3. 异常
* – StackOverflowError:栈深度超过限制
* – OutOfMemoryError:无法分配新的栈帧
*/

}

/**
* Native方法示例
*/

public static void example() {
// Java中的Native方法
System.currentTimeMillis(); // native方法
Object obj = new Object();
obj.hashCode(); // native方法
Thread.currentThread(); // native方法
}
}

4.2 本地方法栈与虚拟机栈的区别

/**
* 本地方法栈与虚拟机栈的区别
*/

public class NativeVsJavaStack {

/**
* 对比分析
*/

public static void comparison() {
/*
* 本地方法栈 vs 虚拟机栈:
*
* | 特性 | 虚拟机栈 | 本地方法栈 |
* |————-|———————-|———————|
* | 服务对象 | Java方法 | Native方法 |
* | 实现语言 | Java字节码 | C/C++等 |
* | 栈帧结构 | 标准栈帧 | 依赖于虚拟机实现 |
* | HotSpot实现 | 独立的栈 | 与虚拟机栈合并 |
* | 异常类型 | StackOverflowError/OOM| StackOverflowError/OOM|
*
* HotSpot虚拟机的实现:
* – 将本地方法栈和虚拟机栈合并为一个栈
* – 不区分Java方法和Native方法的栈帧
* – 简化了实现
*/

}
}

五、堆内存详解

5.1 堆的基本概念

/**
* 堆内存详解
*/

public class JavaHeap {

/**
* 堆的定义
*/

public static void definition() {
/*
* 堆(Heap):
*
* 1. 定义
* – JVM管理的最大的一块内存区域
* – 所有线程共享
* – 存储对象实例和数组
*
* 2. 特点
* – 线程共享:所有线程都可以访问
* – 垃圾回收的主要区域
* – 可以物理上不连续,逻辑上连续
* – 可以动态扩展
*
* 3. 大小设置
* – -Xms:初始堆大小
* – -Xmx:最大堆大小
* – 建议:-Xms和-Xmx设置为相同值,避免动态扩展
* – 示例:-Xms512m -Xmx2g
*
* 4. 异常
* – OutOfMemoryError: Java heap space
* – 原因:堆内存不足,无法分配新对象
*/

}

/**
* 堆的作用
*/

public static void purpose() {
/*
* 堆的主要作用:
*
* 1. 存储对象实例
* – 所有通过new创建的对象
* – 对象的实例数据
* – 对象头信息
*
* 2. 存储数组
* – 所有数组对象
* – 数组元素
*
* 3. 垃圾回收
* – GC的主要工作区域
* – 回收不再使用的对象
* – 释放内存空间
*/

}
}

5.2 堆的结构 – 分代模型

/**
* 堆的分代模型
*/

public class GenerationalHeap {

/**
* 分代模型的定义
*/

public static void definition() {
/*
* 分代模型(Generational Model):
*
* 1. 为什么需要分代
* – 大部分对象朝生夕死(短命对象)
* – 少部分对象长期存活(长命对象)
* – 分代收集可以提高GC效率
*
* 2. 堆的分代结构
*
* ┌─────────────────────────────────────────────────────┐
* │ 堆(Heap) │
* ├─────────────────────────────────────────────────────┤
* │ 新生代(Young Generation) │
* │ ┌──────────┬──────────────┬──────────────┐ │
* │ │ Eden │ Survivor 0 │ Survivor 1 │ │
* │ │ (8) │ (1) │ (1) │ │
* │ └──────────┴──────────────┴──────────────┘ │
* │ │
* │ 老年代(Old Generation) │
* │ ┌──────────────────────────────────────────┐ │
* │ │ │ │
* │ │ │ │
* │ └──────────────────────────────────────────┘ │
* └─────────────────────────────────────────────────────┘
*
* 3. 各代的比例
* – 新生代:老年代 = 1:2(默认)
* – Eden:Survivor0:Survivor1 = 8:1:1(默认)
* – 可通过参数调整:
* -XX:NewRatio=2(新生代:老年代=1:2)
* -XX:SurvivorRatio=8(Eden:Survivor=8:1)
*/

}

/**
* 新生代详解
*/

public static void youngGeneration() {
/*
* 新生代(Young Generation):
*
* 1. 组成
* – Eden区:新对象分配的区域
* – Survivor 0区(From区):存活对象的中转区
* – Survivor 1区(To区):存活对象的中转区
*
* 2. 特点
* – 对象优先在Eden区分配
* – Minor GC频繁发生
* – 大部分对象在Minor GC后被回收
* – 存活的对象移动到Survivor区
*
* 3. 大小设置
* – -Xmn:新生代大小
* – -XX:NewSize:新生代初始大小
* – -XX:MaxNewSize:新生代最大大小
* – 示例:-Xmn512m
*/

}

/**
* 老年代详解
*/

public static void oldGeneration() {
/*
* 老年代(Old Generation):
*
* 1. 定义
* – 存储长期存活的对象
* – 经过多次Minor GC仍然存活的对象
*
* 2. 对象进入老年代的条件
* a. 年龄达到阈值
* – 默认15次Minor GC
* – -XX:MaxTenuringThreshold=15
*
* b. 大对象直接进入
* – 超过-XX:PretenureSizeThreshold的对象
* – 避免在Eden和Survivor之间复制
*
* c. 动态年龄判断
* – Survivor区中相同年龄对象大小总和 > Survivor空间的一半
* – 年龄 >= 该年龄的对象直接进入老年代
*
* d. 空间分配担保
* – Minor GC前检查老年代最大可用连续空间
* – 大于新生代所有对象总和,Minor GC安全
* – 否则,进行Full GC
*
* 3. 特点
* – Major GC/Full GC较少发生
* – GC时间较长
* – 对象存活率高
*/

}
}

5.3 对象分配流程

/**
* 对象分配流程详解
*/

public class ObjectAllocation {

/**
* 对象分配的完整流程
*/

public static void allocationFlow() {
/*
* 对象分配流程:
*
* 1. 尝试在Eden区分配
* ↓
* 2. Eden区空间是否足够?
* ├─ 是 → 在Eden区分配,结束
* └─ 否 → 继续
* ↓
* 3. 是否是大对象?
* ├─ 是 → 直接在老年代分配,结束
* └─ 否 → 继续
* ↓
* 4. 触发Minor GC
* ↓
* 5. 回收Eden区和Survivor区的垃圾对象
* ↓
* 6. 存活对象移动到Survivor区或老年代
* ↓
* 7. Eden区空间是否足够?
* ├─ 是 → 在Eden区分配,结束
* └─ 否 → 继续
* ↓
* 8. 尝试在老年代分配
* ↓
* 9. 老年代空间是否足够?
* ├─ 是 → 在老年代分配,结束
* └─ 否 → 继续
* ↓
* 10. 触发Full GC
* ↓
* 11. 老年代空间是否足够?
* ├─ 是 → 在老年代分配,结束
* └─ 否 → 抛出OutOfMemoryError
*/

}

/**
* 对象分配示例
*/

public static void example() {
// 示例1:小对象在Eden区分配
Object obj1 = new Object(); // 在Eden区分配

// 示例2:大对象直接在老年代分配
byte[] bigObj = new byte[10 * 1024 * 1024]; // 10MB,直接在老年代分配

// 示例3:长期存活的对象进入老年代
List<String> cache = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
cache.add("data" + i); // 经过多次GC后进入老年代
}
}

/**
* Minor GC和Full GC
*/

public static void gcTypes() {
/*
* GC类型:
*
* 1. Minor GC(Young GC)
* – 发生在新生代
* – 频繁发生
* – 速度快
* – 触发条件:Eden区满
*
* 2. Major GC
* – 发生在老年代
* – 较少发生
* – 速度慢
* – 通常伴随至少一次Minor GC
*
* 3. Full GC
* – 清理整个堆(新生代+老年代)和方法区
* – 最慢
* – 触发条件:
* a. 老年代空间不足
* b. 方法区空间不足
* c. System.gc()
* d. 空间分配担保失败
*/

}
}

5.4 TLAB(线程本地分配缓冲)

/**
* TLAB详解
*/

public class ThreadLocalAllocationBuffer {

/**
* TLAB的定义
*/

public static void definition() {
/*
* TLAB(Thread Local Allocation Buffer):
*
* 1. 为什么需要TLAB
* – 堆是线程共享的
* – 多线程并发分配对象时需要同步
* – 同步会影响性能
* – TLAB解决了这个问题
*
* 2. TLAB的原理
* – 每个线程在Eden区预先分配一小块内存
* – 线程在自己的TLAB中分配对象,无需同步
* – TLAB用完后,再申请新的TLAB
* – 大对象无法在TLAB中分配,直接在Eden区分配
*
* 3. TLAB的优势
* – 减少线程同步开销
* – 提高对象分配效率
* – 减少内存碎片
*
* 4. TLAB相关参数
* – -XX:+UseTLAB:启用TLAB(默认启用)
* – -XX:TLABSize:设置TLAB大小
* – -XX:TLABRefillWasteFraction:TLAB填充比例
*/

}

/**
* TLAB的工作流程
*/

public static void workflow() {
/*
* TLAB分配流程:
*
* 1. 线程尝试在TLAB中分配对象
* ↓
* 2. TLAB空间是否足够?
* ├─ 是 → 在TLAB中分配,结束(快速路径)
* └─ 否 → 继续
* ↓
* 3. 对象是否过大?
* ├─ 是 → 直接在Eden区分配(慢速路径,需要同步)
* └─ 否 → 继续
* ↓
* 4. 申请新的TLAB
* ↓
* 5. 在新TLAB中分配对象
*
* 示例:
*/

// 线程1在自己的TLAB中分配
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
Object obj = new Object(); // 在TLAB中分配,无需同步
}
});

// 线程2在自己的TLAB中分配
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
Object obj = new Object(); // 在TLAB中分配,无需同步
}
});

t1.start();
t2.start();

/*
* 两个线程各自在自己的TLAB中分配对象
* 互不干扰,无需同步
*/

}
}

5.5 堆溢出(Heap OOM)

/**
* 堆溢出详解
*/

public class HeapOutOfMemory {

/**
* 堆溢出的原因
*/

public static void causes() {
/*
* OutOfMemoryError: Java heap space的常见原因:
*
* 1. 内存泄漏
* – 对象无法被GC回收
* – 持续创建新对象
* – 堆内存逐渐耗尽
*
* 2. 堆内存设置过小
* – -Xmx设置过小
* – 无法满足应用需求
*
* 3. 创建大量对象
* – 短时间内创建大量对象
* – 超过堆的容量
*
* 4. 大对象
* – 单个对象过大
* – 超过堆的可用空间
*/

}

/**
* 堆溢出示例1:内存泄漏
*/

public static void memoryLeak() {
/*
* 示例:使用静态集合导致内存泄漏
*/

List<byte[]> list = new ArrayList<>();

while (true) {
byte[] data = new byte[1024 * 1024]; // 1MB
list.add(data); // 持续添加,无法被GC回收

// 最终抛出:OutOfMemoryError: Java heap space
}
}

/**
* 堆溢出示例2:大对象
*/

public static void largeObject() {
/*
* 示例:创建超大对象
*/

// 假设堆大小为512MB
byte[] bigArray = new byte[600 * 1024 * 1024]; // 600MB

// 抛出:OutOfMemoryError: Java heap space
}

/**
* 堆溢出的排查方法
*/

public static void troubleshooting() {
/*
* 排查堆溢出的方法:
*
* 1. 生成堆转储文件
* – -XX:+HeapDumpOnOutOfMemoryError
* – -XX:HeapDumpPath=/path/to/dump.hprof
*
* 2. 分析堆转储文件
* – 使用MAT(Memory Analyzer Tool)
* – 使用jvisualvm
* – 使用jhat
*
* 3. 查找内存泄漏
* – 找出占用内存最多的对象
* – 分析对象的引用链
* – 找出无法被GC回收的原因
*
* 4. 优化代码
* – 及时释放不再使用的对象
* – 使用弱引用、软引用
* – 优化数据结构
* – 分批处理大量数据
*/

}

/**
* 堆溢出的解决方案
*/

public static void solutions() {
/*
* 解决堆溢出的方法:
*
* 1. 增加堆内存
* – -Xms2g -Xmx2g
* – 根据应用需求设置合适的大小
*
* 2. 修复内存泄漏
* – 及时清理集合
* – 关闭资源(数据库连接、文件流等)
* – 避免静态集合持有大量对象
*
* 3. 优化对象创建
* – 使用对象池
* – 复用对象
* – 减少临时对象
*
* 4. 分批处理
* – 大量数据分批加载
* – 及时释放已处理的数据
*/

}
}

六、方法区/元空间详解

6.1 方法区的基本概念

/**
* 方法区详解
*/

public class MethodArea {

/**
* 方法区的定义
*/

public static void definition() {
/*
* 方法区(Method Area):
*
* 1. 定义
* – 存储类信息、常量、静态变量、JIT编译后的代码
* – 所有线程共享
* – 逻辑上属于堆的一部分
*
* 2. 存储内容
* – 类的元数据(类名、父类、接口、字段、方法等)
* – 运行时常量池
* – 静态变量
* – JIT编译后的代码缓存
*
* 3. 实现方式
* – JDK 7及之前:永久代(PermGen)
* – JDK 8及之后:元空间(Metaspace)
*
* 4. 异常
* – JDK 7:OutOfMemoryError: PermGen space
* – JDK 8+:OutOfMemoryError: Metaspace
*/

}
}

6.2 永久代 vs 元空间

/**
* 永久代与元空间的对比
*/

public class PermGenVsMetaspace {

/**
* 永久代(PermGen)
*/

public static void permGen() {
/*
* 永久代(Permanent Generation):
*
* 1. 特点
* – JDK 7及之前使用
* – 位于堆内存中
* – 大小固定,不易扩展
* – 容易发生OOM
*
* 2. 参数设置
* – -XX:PermSize:初始大小
* – -XX:MaxPermSize:最大大小
* – 示例:-XX:PermSize=64m -XX:MaxPermSize=256m
*
* 3. 问题
* – 大小难以确定
* – 容易OOM
* – Full GC时需要回收永久代
*/

}

/**
* 元空间(Metaspace)
*/

public static void metaspace() {
/*
* 元空间(Metaspace):
*
* 1. 特点
* – JDK 8及之后使用
* – 位于本地内存(Native Memory)
* – 大小可以动态扩展
* – 默认无上限(受限于系统内存)
*
* 2. 参数设置
* – -XX:MetaspaceSize:初始大小(默认21MB)
* – -XX:MaxMetaspaceSize:最大大小(默认无限制)
* – 示例:-XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m
*
* 3. 优势
* – 不再受堆大小限制
* – 减少Full GC
* – 自动扩展
* – 更好的性能
*
* 4. JDK 7到JDK 8的变化
* – 字符串常量池:从永久代移到堆
* – 静态变量:从永久代移到堆
* – 类的元数据:从永久代移到元空间
*/

}

/**
* 对比表
*/

public static void comparison() {
/*
* 永久代 vs 元空间:
*
* | 特性 | 永久代(PermGen) | 元空间(Metaspace) |
* |————-|———————-|———————-|
* | JDK版本 | JDK 7及之前 | JDK 8及之后 |
* | 位置 | 堆内存 | 本地内存 |
* | 大小 | 固定 | 动态扩展 |
* | 默认上限 | 有限制 | 无限制(受系统内存限制)|
* | GC | Full GC时回收 | 独立回收 |
* | OOM风险 | 高 | 低 |
* | 参数 | -XX:MaxPermSize | -XX:MaxMetaspaceSize |
*/

}
}

6.3 方法区存储的内容

/**
* 方法区存储内容详解
*/

public class MethodAreaContent {

/**
* 类的元数据
*/

public static void classMetadata() {
/*
* 类的元数据包括:
*
* 1. 类的基本信息
* – 类的全限定名
* – 父类的全限定名
* – 实现的接口列表
* – 访问修饰符(public、abstract、final等)
*
* 2. 字段信息
* – 字段名称
* – 字段类型
* – 访问修饰符
* – 字段属性(static、final、volatile等)
*
* 3. 方法信息
* – 方法名称
* – 返回类型
* – 参数列表
* – 访问修饰符
* – 方法属性(static、final、synchronized、native等)
* – 方法的字节码
* – 操作数栈和局部变量表的大小
* – 异常表
*
* 4. 其他信息
* – 常量池引用
* – 注解信息
* – 内部类信息
*/

}

/**
* 示例类
*/

public static class User {
// 静态变量(JDK 8+存储在堆中)
private static int count = 0;

// 实例变量(存储在堆中)
private String name;
private int age;

// 方法信息(存储在方法区)
public User(String name, int age) {
this.name = name;
this.age = age;
count++;
}

public String getName() {
return name;
}
}
}

6.4 元空间溢出

/**
* 元空间溢出详解
*/

public class MetaspaceOOM {

/**
* 元空间溢出的原因
*/

public static void causes() {
/*
* OutOfMemoryError: Metaspace的常见原因:
*
* 1. 动态生成大量类
* – 使用CGLib、ASM等字节码技术
* – 动态代理
* – JSP编译
* – 反射生成类
*
* 2. 类加载器泄漏
* – 自定义类加载器未被回收
* – 加载的类无法卸载
*
* 3. 元空间设置过小
* – -XX:MaxMetaspaceSize设置过小
* – 无法满足应用需求
*/

}

/**
* 元空间溢出示例
*/

public static void example() {
/*
* 示例:使用CGLib动态生成大量类
*/

while (true) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Object.class);
enhancer.setUseCache(false);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object obj, Method method,
Object[] args, MethodProxy proxy) {
return proxy.invokeSuper(obj, args);
}
});
enhancer.create(); // 动态生成类

// 最终抛出:OutOfMemoryError: Metaspace
}
}
}

七、运行时常量池详解

7.1 运行时常量池的基本概念

/**
* 运行时常量池详解
*/

public class RuntimeConstantPool {

/**
* 运行时常量池的定义
*/

public static void definition() {
/*
* 运行时常量池(Runtime Constant Pool):
*
* 1. 定义
* – Class文件中的常量池在类加载后存放的位置
* – 方法区的一部分
* – 每个类都有一个运行时常量池
*
* 2. 存储内容
* – 字面量(Literal)
* – 文本字符串
* – 基本类型的常量值
* – 符号引用(Symbolic References)
* – 类和接口的全限定名
* – 字段的名称和描述符
* – 方法的名称和描述符
*
* 3. 位置变化
* – JDK 6:在永久代
* – JDK 7:在堆中
* – JDK 8+:在堆中(元空间只存储类的元数据)
*
* 4. 动态性
* – 不仅包含编译期的常量
* – 运行期也可以将新的常量放入池中
* – 例如:String.intern()
*/

}
}

7.2 字符串常量池

/**
* 字符串常量池详解
*/

public class StringConstantPool {

/**
* 字符串常量池的定义
*/

public static void definition() {
/*
* 字符串常量池(String Pool):
*
* 1. 定义
* – 存储字符串字面量和intern()的字符串
* – 避免重复创建相同的字符串对象
* – 节省内存
*
* 2. 位置变化
* – JDK 6:在永久代
* – JDK 7+:在堆中
*
* 3. 特点
* – 全局唯一
* – 所有线程共享
* – 字符串字面量自动进入常量池
*/

}

/**
* 字符串字面量示例
*/

public static void literalExample() {
/*
* 示例1:字符串字面量
*/

String s1 = "hello"; // 字面量,存入常量池
String s2 = "hello"; // 从常量池获取

System.out.println(s1 == s2); // true,指向同一个对象

/*
* 内存结构:
*
* 字符串常量池:
* ┌─────────────┐
* │ "hello" │ ← s1和s2都指向这里
* └─────────────┘
*/

}

/**
* new String()示例
*/

public static void newStringExample() {
/*
* 示例2:new String()
*/

String s1 = new String("hello"); // 创建两个对象
String s2 = new String("hello"); // 创建两个对象

System.out.println(s1 == s2); // false,不同对象

/*
* 内存结构:
*
* 字符串常量池:
* ┌─────────────┐
* │ "hello" │
* └─────────────┘
*
* 堆:
* ┌─────────────┐
* │ String对象1 │ ← s1指向这里
* └─────────────┘
* ┌─────────────┐
* │ String对象2 │ ← s2指向这里
* └─────────────┘
*
* new String("hello")创建了两个对象:
* 1. 常量池中的"hello"
* 2. 堆中的String对象
*/

}
}

7.3 String.intern()方法

/**
* String.intern()详解
*/

public class StringIntern {

/**
* intern()方法的定义
*/

public static void definition() {
/*
* String.intern()方法:
*
* 1. 作用
* – 将字符串对象放入常量池
* – 如果常量池中已存在,返回常量池中的引用
* – 如果不存在,将对象引用放入常量池,返回该引用
*
* 2. JDK 6和JDK 7+的区别
* – JDK 6:复制对象到永久代的常量池
* – JDK 7+:在堆的常量池中记录首次出现的引用
*/

}

/**
* JDK 7+的intern()示例
*/

public static void internExample() {
/*
* 示例1:
*/

String s1 = new String("hello");
String s2 = s1.intern();
String s3 = "hello";

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

/*
* 解释:
* 1. new String("hello")创建两个对象:
* – 常量池中的"hello"
* – 堆中的String对象(s1指向)
* 2. s1.intern()发现常量池中已有"hello",返回常量池引用
* 3. s2指向常量池中的"hello"
* 4. s3也指向常量池中的"hello"
* 5. 所以s2 == s3为true
*/

}

/**
* 经典面试题
*/

public static void interviewQuestion() {
/*
* 面试题1:
*/

String s1 = new StringBuilder("ja").append("va").toString();
System.out.println(s1.intern() == s1); // false

String s2 = new StringBuilder("hello").append("world").toString();
System.out.println(s2.intern() == s2); // true

/*
* 解释:
* 1. "java"是JVM内部使用的字符串,已在常量池中
* – s1.intern()返回常量池中的"java"
* – s1指向堆中的对象
* – 所以s1.intern() != s1
*
* 2. "helloworld"首次出现
* – s2.intern()将s2的引用放入常量池
* – 返回s2的引用
* – 所以s2.intern() == s2
*/

}

/**
* intern()的应用场景
*/

public static void useCase() {
/*
* 应用场景:
*
* 1. 大量重复字符串
* – 减少内存占用
* – 提高字符串比较效率
*
* 2. 示例:处理大量URL
*/

List<String> urls = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
String url = new String("http://example.com/page");
urls.add(url.intern()); // 使用intern(),只存储一个对象
}

/*
* 不使用intern():10000个String对象
* 使用intern():1个String对象
*/

}
}

八、直接内存详解

8.1 直接内存的基本概念

/**
* 直接内存详解
*/

public class DirectMemory {

/**
* 直接内存的定义
*/

public static void definition() {
/*
* 直接内存(Direct Memory):
*
* 1. 定义
* – 不属于JVM运行时数据区
* – 位于JVM堆外的本地内存
* – 通过NIO的DirectByteBuffer使用
*
* 2. 特点
* – 不受JVM堆大小限制
* – 不会被GC直接管理
* – 分配和回收成本较高
* – 避免了Java堆和Native堆之间的数据复制
*
* 3. 大小限制
* – 受操作系统内存限制
* – -XX:MaxDirectMemorySize参数设置
* – 默认与-Xmx相同
*
* 4. 异常
* – OutOfMemoryError: Direct buffer memory
*/

}

/**
* 直接内存的使用场景
*/

public static void useCase() {
/*
* 使用场景:
*
* 1. NIO操作
* – 文件读写
* – 网络通信
* – 减少数据复制
*
* 2. 大数据处理
* – 避免GC影响
* – 提高性能
*
* 3. 高性能缓存
* – 堆外缓存
* – 减少GC压力
*/

}
}

8.2 DirectByteBuffer使用示例

import java.nio.ByteBuffer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;

/**
* DirectByteBuffer使用示例
*/

public class DirectByteBufferExample {

/**
* 使用DirectByteBuffer读写文件
*/

public static void fileIO() throws Exception {
/*
* 示例:使用DirectByteBuffer进行文件复制
*/

// 创建直接内存缓冲区
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB

try (FileInputStream fis = new FileInputStream("source.txt");
FileOutputStream fos = new FileOutputStream("target.txt");
FileChannel inChannel = fis.getChannel();
FileChannel outChannel = fos.getChannel()) {

while (inChannel.read(buffer) != –1) {
buffer.flip(); // 切换到读模式
outChannel.write(buffer);
buffer.clear(); // 清空缓冲区
}
}

/*
* 优势:
* 1. 减少数据复制
* – 传统IO:文件 → 内核缓冲区 → JVM堆 → 内核缓冲区 → 文件
* – DirectByteBuffer:文件 → 内核缓冲区 → 直接内存 → 内核缓冲区 → 文件
* 2. 避免GC影响
* 3. 提高IO性能
*/

}

/**
* 堆内存缓冲区 vs 直接内存缓冲区
*/

public static void comparison() {
/*
* 对比:
*
* | 特性 | 堆内存缓冲区 | 直接内存缓冲区 |
* |————-|————————-|————————|
* | 创建方式 | ByteBuffer.allocate() | ByteBuffer.allocateDirect()|
* | 位置 | JVM堆 | 堆外内存 |
* | GC | 受GC管理 | 不受GC直接管理 |
* | 分配速度 | 快 | 慢 |
* | 回收速度 | 快 | 慢 |
* | IO性能 | 较低 | 高 |
* | 适用场景 | 小数据、短生命周期 | 大数据、长生命周期、频繁IO|
*/

}
}

8.3 直接内存溢出

/**
* 直接内存溢出详解
*/

public class DirectMemoryOOM {

/**
* 直接内存溢出示例
*/

public static void example() {
/*
* 示例:分配大量直接内存
*/

List<ByteBuffer> buffers = new ArrayList<>();

while (true) {
ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024); // 1MB
buffers.add(buffer);

// 最终抛出:OutOfMemoryError: Direct buffer memory
}
}

/**
* 直接内存的回收
*/

public static void gc() {
/*
* 直接内存的回收机制:
*
* 1. DirectByteBuffer对象在堆中
* – 包含对直接内存的引用
* – 当DirectByteBuffer对象被GC回收时
* – 通过Cleaner机制回收直接内存
*
* 2. 回收时机
* – Full GC时
* – 显式调用System.gc()
* – 直接内存不足时触发Full GC
*
* 3. 注意事项
* – 直接内存不受-Xmx限制
* – 但受-XX:MaxDirectMemorySize限制
* – 需要合理设置参数
*/

}

/**
* 参数设置建议
*/

public static void parameterSettings() {
/*
* 参数设置:
*
* 1. 设置最大直接内存
* -XX:MaxDirectMemorySize=512m
*
* 2. 监控直接内存使用
* – jconsole
* – jvisualvm
* – JMX
*
* 3. 避免直接内存泄漏
* – 及时释放DirectByteBuffer
* – 使用try-with-resources
* – 避免长时间持有引用
*/

}
}

九、内存溢出案例分析

9.1 各种OOM的原因和解决方案

/**
* 内存溢出案例分析
*/

public class OOMCaseStudy {

/**
* 案例1:堆内存溢出
*/

public static void heapOOM() {
/*
* 错误信息:
* OutOfMemoryError: Java heap space
*
* 原因:
* 1. 内存泄漏:对象无法被GC回收
* 2. 堆内存设置过小
* 3. 创建大量对象
*
* 排查方法:
* 1. 生成堆转储文件
* -XX:+HeapDumpOnOutOfMemoryError
* -XX:HeapDumpPath=/path/to/dump.hprof
*
* 2. 使用MAT分析
* – 查找占用内存最多的对象
* – 分析对象的引用链
* – 找出内存泄漏点
*
* 解决方案:
* 1. 修复内存泄漏
* – 及时清理集合
* – 关闭资源
* – 避免静态集合持有大量对象
*
* 2. 增加堆内存
* -Xms2g -Xmx2g
*
* 3. 优化代码
* – 使用对象池
* – 减少临时对象
* – 分批处理数据
*/

}

/**
* 案例2:栈溢出
*/

public static void stackOverflow() {
/*
* 错误信息:
* StackOverflowError
*
* 原因:
* 1. 无限递归
* 2. 递归深度过大
* 3. 方法调用链过长
*
* 排查方法:
* 1. 查看异常堆栈
* 2. 找出递归调用的方法
* 3. 分析递归终止条件
*
* 解决方案:
* 1. 修复递归逻辑
* – 添加终止条件
* – 减少递归深度
*
* 2. 改用循环
* – 将递归改为迭代
*
* 3. 增加栈大小
* -Xss1m
*/

}
}

/**
* 案例3:元空间溢出
*/
public static void metaspaceOOM() {
/*
* 错误信息:
* OutOfMemoryError: Metaspace
*
* 原因:
* 1. 动态生成大量类
* 2. 类加载器泄漏
* 3. 元空间设置过小
*
* 排查方法:
* 1. 查看类加载情况
* jstat -class <pid>
*
* 2. 分析类加载器
* jmap -clstats <pid>
*
* 3. 检查动态代理
* – CGLib
* – JDK动态代理
* – ASM
*
* 解决方案:
* 1. 修复类加载器泄漏
* – 及时卸载类加载器
* – 避免重复加载类
*
* 2. 增加元空间大小
* -XX:MetaspaceSize=256m
* -XX:MaxMetaspaceSize=512m
*
* 3. 优化动态代理
* – 启用代理缓存
* – 减少动态生成类
*/
}

/**
* 案例4:直接内存溢出
*/
public static void directMemoryOOM() {
/*
* 错误信息:
* OutOfMemoryError: Direct buffer memory
*
* 原因:
* 1. 分配大量DirectByteBuffer
* 2. DirectByteBuffer未被及时回收
* 3. 直接内存设置过小
*
* 排查方法:
* 1. 监控直接内存使用
* – JMX
* – jconsole
*
* 2. 检查NIO使用
* – 查找DirectByteBuffer的使用
* – 检查是否及时释放
*
* 解决方案:
* 1. 及时释放DirectByteBuffer
* – 使用try-with-resources
* – 显式调用System.gc()
*
* 2. 增加直接内存大小
* -XX:MaxDirectMemorySize=512m
*
* 3. 优化NIO使用
* – 复用ByteBuffer
* – 使用对象池
*/
}

}

### 9.2 真实项目中的OOM案例

```java
/**
* 真实项目中的OOM案例
*/
public class RealWorldOOMCases {

/**
* 案例1:ThreadLocal导致的内存泄漏
*/
public static void threadLocalLeak() {
/*
* 场景:
* Web应用使用ThreadLocal存储用户信息
* 使用线程池处理请求
* 请求处理完后未清理ThreadLocal
*
* 问题代码:
*/
class UserContext {
private static ThreadLocal<User> userThreadLocal = new ThreadLocal<>();

public static void setUser(User user) {
userThreadLocal.set(user);
}

public static User getUser() {
return userThreadLocal.get();
}

// 缺少清理方法
}

/*
* 问题:
* 1. 线程池中的线程不会销毁
* 2. ThreadLocal中的对象无法被GC回收
* 3. 随着请求增多,内存逐渐耗尽
*
* 解决方案:
*/
class UserContextFixed {
private static ThreadLocal<User> userThreadLocal = new ThreadLocal<>();

public static void setUser(User user) {
userThreadLocal.set(user);
}

public static User getUser() {
return userThreadLocal.get();
}

// 添加清理方法
public static void clear() {
userThreadLocal.remove();
}
}

/*
* 使用方式:
*/
try {
UserContextFixed.setUser(new User());
// 处理请求
} finally {
UserContextFixed.clear(); // 确保清理
}
}
}

class User {
private String name;
private String email;
}

/**
* 案例2:数据库连接未关闭导致的OOM
*/
public static void connectionLeak() {
/*
* 场景:
* 查询数据库后未关闭连接
* 连接对象无法被GC回收
*
* 问题代码:
*/
void queryData() throws Exception {
Connection conn = DriverManager.getConnection("jdbc:mysql://…");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

while (rs.next()) {
// 处理数据
}

// 未关闭连接
}

/*
* 问题:
* 1. Connection、Statement、ResultSet未关闭
* 2. 占用内存和数据库连接
* 3. 最终导致OOM或连接池耗尽
*
* 解决方案:使用try-with-resources
*/
void queryDataFixed() throws Exception {
try (Connection conn = DriverManager.getConnection("jdbc:mysql://…");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {

while (rs.next()) {
// 处理数据
}
} // 自动关闭资源
}
}

/**
* 案例3:大集合导致的OOM
*/
public static void largeCollectionOOM() {
/*
* 场景:
* 一次性加载大量数据到内存
*
* 问题代码:
*/
void loadAllUsers() {
List<User> users = userDao.findAll(); // 加载100万条数据

for (User user : users) {
// 处理用户
}
}

/*
* 问题:
* 1. 一次性加载100万条数据
* 2. 占用大量内存
* 3. 可能导致OOM
*
* 解决方案:分批加载
*/
void loadUsersBatch() {
int pageSize = 1000;
int pageNum = 0;

while (true) {
List<User> users = userDao.findByPage(pageNum, pageSize);
if (users.isEmpty()) {
break;
}

for (User user : users) {
// 处理用户
}

pageNum++;
}
}
}

}

interface UserDao {
List findAll();
List findByPage(int pageNum, int pageSize);
}

## 十、运行时数据区参数配置

### 10.1 JVM内存参数详解

```java
/**
* JVM内存参数配置
*/
public class JVMMemoryParameters {

/**
* 堆内存参数
*/
public static void heapParameters() {
/*
* 堆内存相关参数:
*
* 1. 基本参数
* -Xms:初始堆大小
* -Xmx:最大堆大小
* -Xmn:新生代大小
*
* 示例:
* -Xms2g -Xmx2g -Xmn512m
*
* 2. 新生代参数
* -XX:NewSize:新生代初始大小
* -XX:MaxNewSize:新生代最大大小
* -XX:NewRatio:新生代与老年代的比例(默认2,即1:2)
* -XX:SurvivorRatio:Eden与Survivor的比例(默认8,即8:1:1)
*
* 示例:
* -XX:NewRatio=2
* -XX:SurvivorRatio=8
*
* 3. 对象晋升参数
* -XX:MaxTenuringThreshold:对象晋升老年代的年龄阈值(默认15)
* -XX:PretenureSizeThreshold:大对象直接进入老年代的阈值
* -XX:TargetSurvivorRatio:Survivor区的目标使用率(默认50%)
*
* 示例:
* -XX:MaxTenuringThreshold=15
* -XX:PretenureSizeThreshold=1048576 // 1MB
*/
}

/**
* 栈内存参数
*/
public static void stackParameters() {
/*
* 栈内存相关参数:
*
* -Xss:每个线程的栈大小
*
* 默认值:
* – Linux:1MB
* – Windows:320KB
*
* 示例:
* -Xss256k // 设置为256KB
* -Xss1m // 设置为1MB
*
* 注意事项:
* 1. 栈太小:容易StackOverflowError
* 2. 栈太大:浪费内存,减少可创建的线程数
* 3. 建议:根据应用的递归深度调整
*/
}

/**
* 元空间参数
*/
public static void metaspaceParameters() {
/*
* 元空间相关参数(JDK 8+):
*
* -XX:MetaspaceSize:初始元空间大小(默认21MB)
* -XX:MaxMetaspaceSize:最大元空间大小(默认无限制)
* -XX:MinMetaspaceFreeRatio:最小空闲比例(默认40%)
* -XX:MaxMetaspaceFreeRatio:最大空闲比例(默认70%)
*
* 示例:
* -XX:MetaspaceSize=128m
* -XX:MaxMetaspaceSize=512m
*
* 永久代参数(JDK 7及之前):
* -XX:PermSize:初始永久代大小
* -XX:MaxPermSize:最大永久代大小
*
* 示例:
* -XX:PermSize=64m
* -XX:MaxPermSize=256m
*/
}

/**
* 直接内存参数
*/
public static void directMemoryParameters() {
/*
* 直接内存相关参数:
*
* -XX:MaxDirectMemorySize:最大直接内存大小
*
* 默认值:与-Xmx相同
*
* 示例:
* -XX:MaxDirectMemorySize=512m
*
* 注意事项:
* 1. 直接内存不受-Xmx限制
* 2. 但受操作系统内存限制
* 3. 需要合理设置,避免OOM
*/
}
}

10.2 参数配置最佳实践

/**
* JVM参数配置最佳实践
*/

public class JVMParameterBestPractices {

/**
* 生产环境推荐配置
*/

public static void productionConfig() {
/*
* 生产环境JVM参数配置示例:
*
* 1. 基础配置(8GB内存服务器)
*
* -Xms4g # 初始堆4GB
* -Xmx4g # 最大堆4GB(与Xms相同,避免动态扩展)
* -Xmn1g # 新生代1GB
* -Xss256k # 栈256KB
* -XX:MetaspaceSize=256m # 元空间初始256MB
* -XX:MaxMetaspaceSize=512m # 元空间最大512MB
* -XX:MaxDirectMemorySize=1g # 直接内存最大1GB
*
* 2. GC配置
* -XX:+UseG1GC # 使用G1垃圾收集器
* -XX:MaxGCPauseMillis=200 # 最大GC停顿时间200ms
* -XX:+ParallelRefProcEnabled # 并行处理引用
*
* 3. GC日志配置
* -XX:+PrintGCDetails # 打印GC详细信息
* -XX:+PrintGCDateStamps # 打印GC时间戳
* -Xloggc:/path/to/gc.log # GC日志文件路径
* -XX:+UseGCLogFileRotation # 启用GC日志轮转
* -XX:NumberOfGCLogFiles=10 # GC日志文件数量
* -XX:GCLogFileSize=100M # 每个GC日志文件大小
*
* 4. OOM时生成堆转储
* -XX:+HeapDumpOnOutOfMemoryError # OOM时生成堆转储
* -XX:HeapDumpPath=/path/to/dump.hprof # 堆转储文件路径
*
* 5. 其他优化参数
* -XX:+DisableExplicitGC # 禁用System.gc()
* -XX:+UseTLAB # 启用TLAB(默认启用)
* -XX:+AlwaysPreTouch # 启动时预分配内存
*/

}

/**
* 不同场景的参数配置
*/

public static void scenarioBasedConfig() {
/*
* 场景1:高并发Web应用
*
* 特点:
* – 大量短生命周期对象
* – 需要快速响应
* – 对GC停顿敏感
*
* 推荐配置:
* -Xms4g -Xmx4g
* -Xmn1g # 较大的新生代
* -XX:+UseG1GC # G1收集器
* -XX:MaxGCPauseMillis=100 # 较短的停顿时间
* -XX:+ParallelRefProcEnabled
*
*
* 场景2:大数据处理应用
*
* 特点:
* – 处理大量数据
* – 对象生命周期长
* – 对吞吐量要求高
*
* 推荐配置:
* -Xms8g -Xmx8g
* -Xmn2g # 较大的新生代
* -XX:+UseParallelGC # Parallel收集器(高吞吐量)
* -XX:ParallelGCThreads=8 # GC线程数
*
*
* 场景3:低延迟应用
*
* 特点:
* – 对响应时间要求极高
* – 不能容忍长时间GC停顿
*
* 推荐配置:
* -Xms4g -Xmx4g
* -XX:+UseZGC # ZGC收集器(JDK 11+)
* -XX:+UnlockExperimentalVMOptions
* -XX:ZCollectionInterval=120 # GC间隔
*
*
* 场景4:微服务应用
*
* 特点:
* – 内存占用小
* – 快速启动
* – 多实例部署
*
* 推荐配置:
* -Xms512m -Xmx512m # 较小的堆
* -Xmn128m
* -XX:+UseSerialGC # Serial收集器(小堆)
* -XX:MetaspaceSize=128m
* -XX:MaxMetaspaceSize=256m
*/

}
}

十一、运行时数据区监控与诊断

11.1 监控工具

/**
* JVM监控工具
*/

public class JVMMonitoringTools {

/**
* 命令行工具
*/

public static void commandLineTools() {
/*
* 1. jps – 查看Java进程
*
* 命令:
* jps -l # 显示完整类名
* jps -v # 显示JVM参数
*
* 输出示例:
* 12345 com.example.Application -Xms2g -Xmx2g
*
*
* 2. jstat – 查看JVM统计信息
*
* 命令:
* jstat -gc <pid> # 查看GC统计
* jstat -gcutil <pid> 1000 10 # 每秒输出一次,共10次
* jstat -class <pid> # 查看类加载统计
*
* 输出示例:
* S0C S1C S0U S1U EC EU OC OU MC MU
* 10240 10240 0 9216 81920 40960 204800 102400 51200 48000
*
*
* 3. jmap – 查看内存映射
*
* 命令:
* jmap -heap <pid> # 查看堆信息
* jmap -histo <pid> # 查看对象统计
* jmap -dump:format=b,file=heap.hprof <pid> # 生成堆转储
*
*
* 4. jstack – 查看线程堆栈
*
* 命令:
* jstack <pid> # 查看线程堆栈
* jstack -l <pid> # 显示锁信息
*
*
* 5. jinfo – 查看和修改JVM参数
*
* 命令:
* jinfo -flags <pid> # 查看JVM参数
* jinfo -flag MaxHeapSize <pid> # 查看特定参数
* jinfo -flag +PrintGC <pid> # 动态开启GC日志
*/

}

/**
* 图形化工具
*/

public static void guiTools() {
/*
* 1. JConsole
*
* 功能:
* – 监控内存使用
* – 监控线程状态
* – 监控类加载
* – 监控MBean
*
* 启动:
* jconsole
*
*
* 2. JVisualVM
*
* 功能:
* – 监控CPU、内存、线程
* – 生成和分析堆转储
* – 性能分析
* – 插件扩展
*
* 启动:
* jvisualvm
*
*
* 3. Java Mission Control (JMC)
*
* 功能:
* – 实时监控
* – Java Flight Recorder分析
* – 性能分析
* – 事件记录
*
* 启动:
* jmc
*
*
* 4. MAT (Memory Analyzer Tool)
*
* 功能:
* – 分析堆转储文件
* – 查找内存泄漏
* – 分析对象引用链
* – 生成分析报告
*
* 使用:
* 1. 生成堆转储:jmap -dump:format=b,file=heap.hprof <pid>
* 2. 用MAT打开heap.hprof文件
* 3. 查看Leak Suspects报告
* 4. 分析Dominator Tree
*/

}
}

11.2 常见问题诊断

/**
* 常见问题诊断方法
*/

public class ProblemDiagnosis {

/**
* 诊断内存泄漏
*/

public static void memoryLeakDiagnosis() {
/*
* 步骤1:确认是否存在内存泄漏
*
* 1. 观察堆内存使用趋势
* jstat -gcutil <pid> 1000
*
* 2. 如果老年代持续增长,可能存在内存泄漏
*
*
* 步骤2:生成堆转储
*
* jmap -dump:format=b,file=heap1.hprof <pid>
* # 等待一段时间
* jmap -dump:format=b,file=heap2.hprof <pid>
*
*
* 步骤3:使用MAT分析
*
* 1. 打开heap2.hprof
* 2. 查看Leak Suspects报告
* 3. 分析Dominator Tree,找出占用内存最多的对象
* 4. 查看对象的引用链(Path to GC Roots)
* 5. 找出无法被GC回收的原因
*
*
* 步骤4:定位代码
*
* 1. 根据对象类型定位代码
* 2. 检查是否有集合未清理
* 3. 检查是否有资源未关闭
* 4. 检查是否有ThreadLocal未清理
*
*
* 常见内存泄漏场景:
* 1. 静态集合持有对象
* 2. ThreadLocal未清理
* 3. 监听器未移除
* 4. 数据库连接未关闭
* 5. 缓存未设置过期时间
*/

}

/**
* 诊断CPU使用率高
*/

public static void highCPUDiagnosis() {
/*
* 步骤1:找出占用CPU高的进程
*
* top
* # 找到Java进程的PID
*
*
* 步骤2:找出占用CPU高的线程
*
* top -Hp <pid>
* # 记录占用CPU高的线程ID(十进制)
*
*
* 步骤3:转换线程ID为十六进制
*
* printf "%x\\n" <线程ID>
* # 例如:printf "%x\\n" 12345
* # 输出:3039
*
*
* 步骤4:查看线程堆栈
*
* jstack <pid> | grep -A 20 <十六进制线程ID>
* # 例如:jstack 12345 | grep -A 20 3039
*
*
* 步骤5:分析堆栈信息
*
* 1. 查看线程在执行什么代码
* 2. 是否有死循环
* 3. 是否有大量计算
* 4. 是否有频繁的GC
*
*
* 常见CPU高的原因:
* 1. 死循环
* 2. 频繁的Full GC
* 3. 大量的正则表达式匹配
* 4. 大量的序列化/反序列化
* 5. 大量的反射调用
*/

}

/**
* 诊断频繁GC
*/

public static void frequentGCDiagnosis() {
/*
* 步骤1:查看GC统计
*
* jstat -gcutil <pid> 1000
*
* 观察:
* – YGC:Young GC次数
* – YGCT:Young GC总时间
* – FGC:Full GC次数
* – FGCT:Full GC总时间
*
*
* 步骤2:分析GC日志
*
* 1. 查看GC频率
* 2. 查看GC停顿时间
* 3. 查看GC前后的内存变化
*
*
* 步骤3:找出原因
*
* 1. 堆内存过小
* – 增加堆内存:-Xms -Xmx
*
* 2. 新生代过小
* – 增加新生代:-Xmn
*
* 3. 创建大量临时对象
* – 优化代码,减少对象创建
* – 使用对象池
*
* 4. 内存泄漏
* – 使用MAT分析堆转储
* – 修复内存泄漏
*/

}
}

十二、面试题详解

12.1 基础面试题

/**
* 运行时数据区基础面试题
*/

public class BasicInterviewQuestions {

/**
* 面试题1:JVM运行时数据区有哪些?
*/

public static void question1() {
/*
* 答案:
*
* JVM运行时数据区分为两大类:
*
* 一、线程私有区域:
* 1. 程序计数器(Program Counter Register)
* – 记录当前线程执行的字节码行号
* – 唯一不会OOM的区域
*
* 2. 虚拟机栈(Java Virtual Machine Stack)
* – 描述Java方法执行的内存模型
* – 每个方法执行时创建一个栈帧
* – 可能抛出StackOverflowError和OOM
*
* 3. 本地方法栈(Native Method Stack)
* – 为Native方法服务
* – HotSpot将其与虚拟机栈合并
*
* 二、线程共享区域:
* 1. 堆(Heap)
* – 存储对象实例和数组
* – 垃圾回收的主要区域
* – 分为新生代和老年代
*
* 2. 方法区/元空间(Method Area/Metaspace)
* – 存储类信息、常量、静态变量
* – JDK 8之前是永久代,JDK 8之后是元空间
*
* 三、其他:
* 1. 直接内存(Direct Memory)
* – 不属于JVM运行时数据区
* – NIO使用
*/

}

/**
* 面试题2:堆和栈的区别?
*/

public static void question2() {
/*
* 答案:
*
* | 特性 | 堆(Heap) | 栈(Stack) |
* |————-|————————|———————-|
* | 作用 | 存储对象实例和数组 | 存储方法调用和局部变量 |
* | 线程 | 所有线程共享 | 线程私有 |
* | 生命周期 | 对象创建到GC回收 | 方法调用到返回 |
* | 大小 | 较大(GB级别) | 较小(MB级别) |
* | 分配速度 | 较慢(需要同步) | 快(指针移动) |
* | 回收方式 | GC自动回收 | 自动出栈 |
* | 异常 | OutOfMemoryError | StackOverflowError |
* | 参数 | -Xms -Xmx | -Xss |
*
* 示例:
*/

// 栈:存储局部变量和方法调用
int a = 10; // 基本类型,存储在栈中

// 堆:存储对象实例
Object obj = new Object(); // 对象实例存储在堆中,obj引用存储在栈中
}

/**
* 面试题3:什么是栈帧?栈帧包含哪些内容?
*/

public static void question3() {
/*
* 答案:
*
* 栈帧(Stack Frame)是虚拟机栈的基本单位,每个方法执行时创建一个栈帧。
*
* 栈帧包含:
*
* 1. 局部变量表(Local Variables)
* – 存储方法参数和局部变量
* – 以Slot为单位
* – 实例方法的Slot 0存储this引用
*
* 2. 操作数栈(Operand Stack)
* – 存储方法执行过程中的中间结果
* – 进行算术运算
* – 方法调用和返回
*
* 3. 动态链接(Dynamic Linking)
* – 指向运行时常量池的方法引用
* – 支持动态分派(多态)
*
* 4. 返回地址(Return Address)
* – 方法正常退出:调用者的PC
* – 方法异常退出:异常处理器地址
*/

}
}

12.2 进阶面试题

/**
* 运行时数据区进阶面试题
*/

public class AdvancedInterviewQuestions {

/**
* 面试题4:永久代和元空间的区别?为什么要用元空间替代永久代?
*/

public static void question4() {
/*
* 答案:
*
* 区别:
*
* | 特性 | 永久代(PermGen) | 元空间(Metaspace) |
* |————-|———————-|———————-|
* | JDK版本 | JDK 7及之前 | JDK 8及之后 |
* | 位置 | 堆内存 | 本地内存 |
* | 大小 | 固定 | 动态扩展 |
* | 默认上限 | 有限制 | 无限制(受系统内存限制)|
* | GC | Full GC时回收 | 独立回收 |
* | 参数 | -XX:MaxPermSize | -XX:MaxMetaspaceSize |
*
*
* 为什么要替代永久代:
*
* 1. 永久代大小难以确定
* – 类的数量不确定
* – 容易OOM
* – 需要频繁调整参数
*
* 2. 永久代会导致Full GC
* – 永久代满时触发Full GC
* – 影响性能
*
* 3. 元空间的优势
* – 使用本地内存,不受堆大小限制
* – 自动扩展,减少OOM
* – 减少Full GC
* – 更好的性能
*
* 4. 统一HotSpot和JRockit
* – JRockit没有永久代
* – 统一实现
*/

}

/**
* 面试题5:对象一定分配在堆上吗?
*/

public static void question5() {
/*
* 答案:
*
* 不一定。有两种情况对象不在堆上分配:
*
* 1. 栈上分配(Stack Allocation)
*
* 条件:
* – 对象作用域不会逃逸出方法
* – 对象大小不超过限制
* – 开启逃逸分析:-XX:+DoEscapeAnalysis(默认开启)
*
* 示例:
*/

void method() {
Point p = new Point(1, 2); // p不会逃逸出方法
int x = p.getX();
// p可能在栈上分配
}

/*
* 优势:
* – 随着方法结束自动回收
* – 不需要GC
* – 提高性能
*
*
* 2. 标量替换(Scalar Replacement)
*
* 条件:
* – 对象不会逃逸
* – 对象可以被拆分为基本类型
* – 开启标量替换:-XX:+EliminateAllocations(默认开启)
*
* 示例:
*/

void method2() {
Point p = new Point(1, 2);
int x = p.getX();
int y = p.getY();

// 经过标量替换后,等价于:
// int x = 1;
// int y = 2;
// 不需要创建Point对象
}

/*
* 优势:
* – 完全消除对象分配
* – 进一步提高性能
*/

}

/**
* 面试题6:String s = new String("abc")创建了几个对象?
*/

public static void question6() {
/*
* 答案:
*
* 创建了1个或2个对象,取决于字符串常量池中是否已存在"abc"。
*
* 情况1:常量池中不存在"abc"
* – 创建2个对象:
* 1. 字符串常量池中的"abc"
* 2. 堆中的String对象
*
* 情况2:常量池中已存在"abc"
* – 创建1个对象:
* 1. 堆中的String对象
*
* 详细分析:
*/

// 第一次执行
String s1 = new String("abc");
/*
* 1. 检查常量池,不存在"abc"
* 2. 在常量池创建"abc"
* 3. 在堆中创建String对象
* 4. s1指向堆中的对象
*
* 创建了2个对象
*/

// 第二次执行
String s2 = new String("abc");
/*
* 1. 检查常量池,已存在"abc"
* 2. 在堆中创建String对象
* 3. s2指向堆中的对象
*
* 创建了1个对象
*/

System.out.println(s1 == s2); // false,不同对象

String s3 = "abc";
System.out.println(s1 == s3); // false,s1在堆,s3在常量池
}
}

class Point {
private int x;
private int y;

public Point(int x, int y) {
this.x = x;
this.y = y;
}

public int getX() { return x; }
public int getY() { return y; }
}

12.3 高频面试题

/**
* 运行时数据区高频面试题
*/

public class FrequentInterviewQuestions {

/**
* 面试题7:如何判断对象可以被回收?
*/

public static void question7() {
/*
* 答案:
*
* 主要有两种算法:
*
* 1. 引用计数法(Reference Counting)
*
* 原理:
* – 给对象添加一个引用计数器
* – 每当有引用指向它,计数器+1
* – 引用失效时,计数器-1
* – 计数器为0时,对象可以被回收
*
* 优点:
* – 实现简单
* – 判断效率高
*
* 缺点:
* – 无法解决循环引用问题
* – 需要额外的空间存储计数器
*
* 示例:
*/

class Node {
Node next;
}

Node a = new Node();
Node b = new Node();
a.next = b;
b.next = a; // 循环引用

a = null;
b = null;
// 两个对象互相引用,计数器不为0,无法回收

/*
* 2. 可达性分析算法(Reachability Analysis)
*
* 原理:
* – 从GC Roots开始向下搜索
* – 搜索走过的路径称为引用链
* – 如果对象到GC Roots没有引用链,则对象不可达,可以被回收
*
* GC Roots包括:
* – 虚拟机栈中引用的对象
* – 方法区中静态属性引用的对象
* – 方法区中常量引用的对象
* – 本地方法栈中引用的对象
* – JVM内部引用(类加载器、异常对象等)
* – 被同步锁持有的对象
*
* 优点:
* – 可以解决循环引用问题
* – 主流JVM都采用此算法
*
* Java使用可达性分析算法
*/

}

/**
* 面试题8:Minor GC、Major GC、Full GC的区别?
*/

public static void question8() {
/*
* 答案:
*
* 1. Minor GC(Young GC)
*
* 定义:
* – 发生在新生代的垃圾回收
*
* 触发条件:
* – Eden区满
*
* 特点:
* – 频繁发生
* – 速度快(通常几十毫秒)
* – 使用复制算法
*
* 过程:
* 1. Eden区和From Survivor区的存活对象复制到To Survivor区
* 2. 清空Eden区和From Survivor区
* 3. From和To交换角色
* 4. 年龄达到阈值的对象晋升到老年代
*
*
* 2. Major GC
*
* 定义:
* – 发生在老年代的垃圾回收
*
* 触发条件:
* – 老年代空间不足
*
* 特点:
* – 较少发生
* – 速度慢(通常几百毫秒到几秒)
* – 通常伴随至少一次Minor GC
*
*
* 3. Full GC
*
* 定义:
* – 清理整个堆(新生代+老年代)和方法区
*
* 触发条件:
* – 老年代空间不足
* – 方法区空间不足
* – System.gc()
* – 空间分配担保失败
* – Concurrent Mode Failure(CMS)
*
* 特点:
* – 最慢(可能几秒到几十秒)
* – Stop The World时间最长
* – 应该尽量避免
*
*
* 对比表:
*
* | 类型 | 区域 | 频率 | 速度 | 影响 |
* |———-|——————|——–|——–|———-|
* | Minor GC | 新生代 | 高 | 快 | 小 |
* | Major GC | 老年代 | 中 | 慢 | 中 |
* | Full GC | 新生代+老年代+方法区| 低 | 最慢 | 大 |
*/

}

/**
* 面试题9:什么情况下会发生栈溢出?
*/

public static void question9() {
/*
* 答案:
*
* 栈溢出(StackOverflowError)的常见原因:
*
* 1. 无限递归
*
* 示例:
*/

void recursion() {
recursion(); // 无终止条件
}

/*
* 2. 递归深度过大
*
* 示例:
*/

long factorial(int n) {
if (n == 0) return 1;
return n * factorial(n – 1);
}
// factorial(100000) 会栈溢出

/*
* 3. 方法调用链过长
*
* 示例:
*/

void method1() { method2(); }
void method2() { method3(); }
void method3() { method4(); }
// … 调用链过长

/*
* 4. 局部变量过多或过大
*
* 示例:
*/

void method() {
int[] arr1 = new int[10000];
int[] arr2 = new int[10000];
// … 大量局部变量
}

/*
* 解决方案:
*
* 1. 修复递归逻辑
* – 添加终止条件
* – 减少递归深度
*
* 2. 改用循环
* – 将递归改为迭代
*
* 3. 增加栈大小
* – -Xss1m
*
* 4. 优化代码
* – 减少局部变量
* – 优化方法调用
*/

}

/**
* 面试题10:如何排查内存泄漏?
*/

public static void question10() {
/*
* 答案:
*
* 排查内存泄漏的步骤:
*
* 1. 确认是否存在内存泄漏
*
* 方法:
* – 观察堆内存使用趋势
* – 使用jstat -gcutil <pid> 1000
* – 如果老年代持续增长,可能存在内存泄漏
*
*
* 2. 生成堆转储文件
*
* 方法:
* – jmap -dump:format=b,file=heap.hprof <pid>
* – 或配置:-XX:+HeapDumpOnOutOfMemoryError
*
*
* 3. 分析堆转储文件
*
* 工具:
* – MAT(Memory Analyzer Tool)
* – JVisualVM
* – JProfiler
*
* 步骤:
* a. 打开堆转储文件
* b. 查看Leak Suspects报告
* c. 分析Dominator Tree,找出占用内存最多的对象
* d. 查看对象的引用链(Path to GC Roots)
* e. 找出无法被GC回收的原因
*
*
* 4. 定位代码
*
* 方法:
* – 根据对象类型定位代码
* – 检查集合是否未清理
* – 检查资源是否未关闭
* – 检查ThreadLocal是否未清理
* – 检查监听器是否未移除
*
*
* 5. 修复问题
*
* 常见修复方法:
* – 及时清理集合
* – 使用try-with-resources关闭资源
* – 在finally中清理ThreadLocal
* – 移除不再使用的监听器
* – 使用弱引用、软引用
*
*
* 常见内存泄漏场景:
* 1. 静态集合持有对象
* 2. ThreadLocal未清理
* 3. 监听器未移除
* 4. 数据库连接未关闭
* 5. 缓存未设置过期时间
* 6. 内部类持有外部类引用
*/

}
}

十三、实战练习题

13.1 基础练习

/**
* 运行时数据区基础练习题
*/

public class BasicExercises {

/**
* 练习1:分析以下代码的内存分配
*/

public static void exercise1() {
/*
* 题目:
* 分析以下代码中各个变量的内存分配位置
*/

int a = 10; // 问题1:a存储在哪里?
String s = "hello"; // 问题2:s和"hello"分别存储在哪里?
Object obj = new Object(); // 问题3:obj和Object实例分别存储在哪里?

/*
* 答案:
*
* 问题1:a存储在虚拟机栈的局部变量表中
* – 基本类型的值直接存储在栈中
*
* 问题2:
* – s(引用)存储在虚拟机栈的局部变量表中
* – "hello"(字符串对象)存储在堆中的字符串常量池
*
* 问题3:
* – obj(引用)存储在虚拟机栈的局部变量表中
* – Object实例存储在堆中
*/

}

/**
* 练习2:判断以下代码是否会发生OOM,如果会,是哪种OOM?
*/

public static void exercise2() {
/*
* 题目1:
*/

List<byte[]> list = new ArrayList<>();
while (true) {
list.add(new byte[1024 * 1024]); // 1MB
}

/*
* 答案:
* 会发生OOM:OutOfMemoryError: Java heap space
* 原因:持续向堆中添加对象,堆内存耗尽
*/

/*
* 题目2:
*/

void recursion() {
recursion();
}

/*
* 答案:
* 会发生StackOverflowError
* 原因:无限递归,栈深度超过限制
*/

/*
* 题目3:
*/

while (true) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Object.class);
enhancer.setUseCache(false);
enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) ->
proxy.invokeSuper(obj, args));
enhancer.create();
}

/*
* 答案:
* 会发生OOM:OutOfMemoryError: Metaspace
* 原因:动态生成大量类,元空间耗尽
*/

}
}

13.2 进阶练习

/**
* 运行时数据区进阶练习题
*/

public class AdvancedExercises {

/**
* 练习3:分析String的内存分配
*/

public static void exercise3() {
/*
* 题目:
* 分析以下代码的输出结果,并解释原因
*/

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");

System.out.println(s1 == s2); // 问题1:输出什么?
System.out.println(s1 == s3); // 问题2:输出什么?
System.out.println(s3 == s4); // 问题3:输出什么?
System.out.println(s3.intern() == s1); // 问题4:输出什么?

/*
* 答案:
*
* 问题1:true
* 原因:s1和s2都指向字符串常量池中的"hello"
*
* 问题2:false
* 原因:s1指向常量池,s3指向堆中的对象
*
* 问题3:false
* 原因:s3和s4是两个不同的堆对象
*
* 问题4:true
* 原因:s3.intern()返回常量池中的"hello",与s1相同
*/

}

/**
* 练习4:分析对象的晋升过程
*/

public static void exercise4() {
/*
* 题目:
* 假设JVM参数如下:
* -Xms20m -Xmx20m -Xmn10m -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=15
*
* 计算各区域的大小,并分析对象的分配和晋升过程
*/

/*
* 答案:
*
* 1. 堆大小:20MB
* – 新生代:10MB
* – 老年代:10MB
*
* 2. 新生代分配(SurvivorRatio=8):
* – Eden:8MB
* – Survivor0:1MB
* – Survivor1:1MB
*
* 3. 对象分配流程:
* a. 对象优先在Eden区分配
* b. Eden区满时,触发Minor GC
* c. 存活对象移动到Survivor区
* d. 年龄+1
* e. 年龄达到15时,晋升到老年代
*
* 4. 特殊情况:
* a. 大对象(超过PretenureSizeThreshold)直接进入老年代
* b. Survivor区放不下的对象直接进入老年代
* c. 动态年龄判断:Survivor区中相同年龄对象大小总和 > Survivor空间的一半,
* 年龄 >= 该年龄的对象直接进入老年代
*/

}

/**
* 练习5:分析栈帧的变化
*/

public static void exercise5() {
/*
* 题目:
* 分析以下代码的栈帧变化过程
*/

public static void main(String[] args) {
int result = add(10, 20);
System.out.println(result);
}

public static int add(int a, int b) {
int sum = a + b;
return sum;
}

/*
* 答案:
*
* 栈帧变化过程:
*
* 1. main方法开始执行
* ┌─────────────────────┐
* │ main栈帧 │
* │ 局部变量表: │
* │ Slot 0: args │
* └─────────────────────┘
*
* 2. 调用add方法
* ┌─────────────────────┐
* │ add栈帧 │
* │ 局部变量表: │
* │ Slot 0: a = 10 │
* │ Slot 1: b = 20 │
* │ Slot 2: sum = 30 │
* ├─────────────────────┤
* │ main栈帧 │
* │ 局部变量表: │
* │ Slot 0: args │
* └─────────────────────┘
*
* 3. add方法返回
* – 将返回值30压入main的操作数栈
* – add栈帧出栈
* ┌─────────────────────┐
* │ main栈帧 │
* │ 局部变量表: │
* │ Slot 0: args │
* │ Slot 1: result=30 │
* │ 操作数栈: │
* │ 30 │
* └─────────────────────┘
*
* 4. main方法继续执行
* – 从操作数栈弹出30
* – 存储到局部变量表的result
* – 打印result
*/

}
}

13.3 综合练习

/**
* 运行时数据区综合练习题
*/

public class ComprehensiveExercises {

/**
* 练习6:设计一个内存监控工具
*/

public static void exercise6() {
/*
* 题目:
* 设计一个简单的内存监控工具,能够:
* 1. 监控堆内存使用情况
* 2. 监控各代的内存使用情况
* 3. 监控GC次数和时间
* 4. 当内存使用超过阈值时发出警告
*/

/*
* 答案:
*/

import java.lang.management.*;

class MemoryMonitor {
private static final double WARNING_THRESHOLD = 0.8; // 80%

public void monitor() {
// 获取内存管理MXBean
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();

// 堆内存使用情况
MemoryUsage heapUsage = memoryMXBean.getHeapMemoryUsage();
long heapUsed = heapUsage.getUsed();
long heapMax = heapUsage.getMax();
double heapUsageRatio = (double) heapUsed / heapMax;

System.out.println("堆内存使用:" + heapUsed / 1024 / 1024 + "MB / "
+ heapMax / 1024 / 1024 + "MB");
System.out.println("堆内存使用率:" + String.format("%.2f%%", heapUsageRatio * 100));

// 非堆内存使用情况
MemoryUsage nonHeapUsage = memoryMXBean.getNonHeapMemoryUsage();
long nonHeapUsed = nonHeapUsage.getUsed();
long nonHeapMax = nonHeapUsage.getMax();

System.out.println("非堆内存使用:" + nonHeapUsed / 1024 / 1024 + "MB");

// 各代内存使用情况
for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
String name = pool.getName();
MemoryUsage usage = pool.getUsage();
long used = usage.getUsed();
long max = usage.getMax();

System.out.println(name + ":" + used / 1024 / 1024 + "MB / "
+ (max == –1 ? "无限制" : max / 1024 / 1024 + "MB"));
}

// GC统计
for (GarbageCollectorMXBean gc : ManagementFactory.getGarbageCollectorMXBeans()) {
String name = gc.getName();
long count = gc.getCollectionCount();
long time = gc.getCollectionTime();

System.out.println(name + " GC次数:" + count + ",总时间:" + time + "ms");
}

// 内存警告
if (heapUsageRatio > WARNING_THRESHOLD) {
System.err.println("警告:堆内存使用率超过" + (WARNING_THRESHOLD * 100) + "%!");
}
}
}
}

/**
* 练习7:实现一个对象池
*/

public static void exercise7() {
/*
* 题目:
* 实现一个简单的对象池,减少对象创建和GC压力
* 要求:
* 1. 支持对象的获取和归还
* 2. 池中对象数量有上限
* 3. 线程安全
*/

/*
* 答案:
*/

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class ObjectPool<T> {
private final BlockingQueue<T> pool;
private final ObjectFactory<T> factory;
private final int maxSize;

public ObjectPool(ObjectFactory<T> factory, int maxSize) {
this.factory = factory;
this.maxSize = maxSize;
this.pool = new LinkedBlockingQueue<>(maxSize);

// 预创建对象
for (int i = 0; i < maxSize; i++) {
pool.offer(factory.create());
}
}

// 获取对象
public T borrow() throws InterruptedException {
return pool.take();
}

// 归还对象
public void returnObject(T obj) {
if (obj != null) {
factory.reset(obj); // 重置对象状态
pool.offer(obj);
}
}

// 获取池中对象数量
public int size() {
return pool.size();
}
}

interface ObjectFactory<T> {
T create();
void reset(T obj);
}

// 使用示例
class ConnectionFactory implements ObjectFactory<Connection> {
@Override
public Connection create() {
return new Connection();
}

@Override
public void reset(Connection conn) {
conn.reset();
}
}

// 使用对象池
ObjectPool<Connection> pool = new ObjectPool<>(new ConnectionFactory(), 10);

try {
Connection conn = pool.borrow();
// 使用连接
conn.execute();
} finally {
pool.returnObject(conn);
}
}
}

class Connection {
public void execute() {
// 执行操作
}

public void reset() {
// 重置状态
}
}

13.4 实战项目练习

/**
* 运行时数据区实战项目练习
*/

public class ProjectExercises {

/**
* 练习8:优化一个存在内存泄漏的Web应用
*/

public static void exercise8() {
/*
* 题目:
* 以下是一个存在内存泄漏的Web应用代码,找出问题并修复
*/

// 问题代码
@WebFilter("/*")
class UserContextFilter implements Filter {
private static ThreadLocal<User> userThreadLocal = new ThreadLocal<>();

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
String userId = req.getHeader("userId");

User user = userService.findById(userId);
userThreadLocal.set(user);

chain.doFilter(request, response);

// 问题:未清理ThreadLocal
}
}

/*
* 问题分析:
* 1. Web容器使用线程池处理请求
* 2. 线程不会销毁,会被复用
* 3. ThreadLocal中的User对象无法被GC回收
* 4. 随着请求增多,内存逐渐耗尽
*
* 修复方案:
*/

@WebFilter("/*")
class UserContextFilterFixed implements Filter {
private static ThreadLocal<User> userThreadLocal = new ThreadLocal<>();

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
try {
HttpServletRequest req = (HttpServletRequest) request;
String userId = req.getHeader("userId");

User user = userService.findById(userId);
userThreadLocal.set(user);

chain.doFilter(request, response);
} finally {
// 确保清理ThreadLocal
userThreadLocal.remove();
}
}
}
}

/**
* 练习9:优化一个频繁Full GC的应用
*/

public static void exercise9() {
/*
* 题目:
* 一个数据处理应用频繁发生Full GC,分析原因并优化
*/

// 问题代码
class DataProcessor {
public void process() {
// 一次性加载100万条数据
List<Data> dataList = dataDao.findAll(); // 100万条

for (Data data : dataList) {
// 处理数据
processData(data);
}
}

private void processData(Data data) {
// 处理逻辑
}
}

/*
* 问题分析:
* 1. 一次性加载100万条数据到内存
* 2. 占用大量堆内存
* 3. 触发频繁的Full GC
* 4. 影响性能
*
* 优化方案1:分批加载
*/

class DataProcessorOptimized1 {
private static final int BATCH_SIZE = 1000;

public void process() {
int pageNum = 0;

while (true) {
// 分批加载,每次1000条
List<Data> dataList = dataDao.findByPage(pageNum, BATCH_SIZE);
if (dataList.isEmpty()) {
break;
}

for (Data data : dataList) {
processData(data);
}

pageNum++;
}
}

private void processData(Data data) {
// 处理逻辑
}
}

/*
* 优化方案2:使用流式处理
*/

class DataProcessorOptimized2 {
public void process() {
// 使用流式查询,逐条处理
dataDao.stream().forEach(data -> {
processData(data);
});
}

private void processData(Data data) {
// 处理逻辑
}
}

/*
* 优化效果:
* 1. 减少内存占用
* 2. 减少Full GC频率
* 3. 提高处理速度
* 4. 提高系统稳定性
*/

}

/**
* 练习10:实现一个堆外缓存
*/

public static void exercise10() {
/*
* 题目:
* 实现一个基于DirectByteBuffer的堆外缓存,减少GC压力
*/

/*
* 答案:
*/

import java.nio.ByteBuffer;
import java.util.concurrent.ConcurrentHashMap;

class OffHeapCache {
private final ConcurrentHashMap<String, ByteBuffer> cache;
private final int maxSize;
private final int bufferSize;

public OffHeapCache(int maxSize, int bufferSize) {
this.cache = new ConcurrentHashMap<>();
this.maxSize = maxSize;
this.bufferSize = bufferSize;
}

// 存储数据
public void put(String key, byte[] data) {
if (cache.size() >= maxSize) {
// 简单的LRU策略:移除第一个元素
String firstKey = cache.keys().nextElement();
remove(firstKey);
}

// 分配直接内存
ByteBuffer buffer = ByteBuffer.allocateDirect(data.length);
buffer.put(data);
buffer.flip();

cache.put(key, buffer);
}

// 获取数据
public byte[] get(String key) {
ByteBuffer buffer = cache.get(key);
if (buffer == null) {
return null;
}

byte[] data = new byte[buffer.remaining()];
buffer.get(data);
buffer.rewind(); // 重置position

return data;
}

// 移除数据
public void remove(String key) {
ByteBuffer buffer = cache.remove(key);
if (buffer != null) {
// 释放直接内存
((sun.nio.ch.DirectBuffer) buffer).cleaner().clean();
}
}

// 清空缓存
public void clear() {
cache.forEach((key, buffer) -> {
((sun.nio.ch.DirectBuffer) buffer).cleaner().clean();
});
cache.clear();
}

// 获取缓存大小
public int size() {
return cache.size();
}
}

/*
* 使用示例:
*/

OffHeapCache cache = new OffHeapCache(1000, 1024);

// 存储数据
cache.put("key1", "value1".getBytes());

// 获取数据
byte[] data = cache.get("key1");

// 移除数据
cache.remove("key1");

// 清空缓存
cache.clear();

/*
* 优势:
* 1. 数据存储在堆外,不受GC影响
* 2. 减少GC压力
* 3. 提高性能
*
* 注意事项:
* 1. 需要手动管理内存
* 2. 需要及时释放直接内存
* 3. 直接内存分配和释放成本较高
*/

}
}

interface DataDao {
List<Data> findAll();
List<Data> findByPage(int pageNum, int pageSize);
void stream();
}

class Data {
private String id;
private String content;
}

interface UserService {
User findById(String userId);
}

十四、学习检查清单

14.1 知识点掌握检查

运行时数据区学习检查清单

□ 基础概念
□ 能够说出JVM运行时数据区的完整结构
□ 理解线程私有区域和线程共享区域的区别
□ 掌握各个区域的作用和特点
□ 了解各个区域可能抛出的异常

□ 程序计数器
□ 理解程序计数器的作用
□ 知道为什么程序计数器不会OOM
□ 理解程序计数器与多线程的关系
□ 了解Native方法执行时程序计数器的状态

□ 虚拟机栈
□ 理解虚拟机栈的工作原理
□ 掌握栈帧的完整结构
□ 理解局部变量表的组成和Slot的概念
□ 理解操作数栈的作用和工作流程
□ 理解动态链接的作用
□ 理解方法返回地址的作用
□ 掌握StackOverflowError的原因和解决方案
□ 能够分析方法调用的栈帧变化

□ 本地方法栈
□ 理解本地方法栈的作用
□ 了解HotSpot虚拟机的实现方式

□ 堆内存
□ 理解堆的作用和特点
□ 掌握堆的分代模型(新生代、老年代)
□ 理解Eden区和Survivor区的作用
□ 掌握对象分配流程
□ 理解对象晋升到老年代的条件
□ 了解TLAB的作用和原理
□ 掌握堆溢出的原因和排查方法
□ 能够设置堆内存相关参数

□ 方法区/元空间
□ 理解方法区的作用
□ 掌握永久代和元空间的区别
□ 理解为什么要用元空间替代永久代
□ 了解方法区存储的内容
□ 掌握元空间溢出的原因和解决方案
□ 能够设置元空间相关参数

□ 运行时常量池
□ 理解运行时常量池的作用
□ 掌握字符串常量池的位置变化
□ 理解String.intern()方法的原理
□ 能够分析字符串的内存分配

□ 直接内存
□ 理解直接内存的概念
□ 掌握DirectByteBuffer的使用
□ 了解直接内存的优势和劣势
□ 掌握直接内存溢出的原因和解决方案

□ 内存溢出
□ 掌握各种OOM的原因和解决方案
□ 能够使用工具排查内存泄漏
□ 了解常见的内存泄漏场景
□ 能够分析和修复内存泄漏问题

□ JVM参数
□ 掌握堆内存相关参数
□ 掌握栈内存相关参数
□ 掌握元空间相关参数
□ 掌握直接内存相关参数
□ 能够根据场景配置JVM参数

□ 监控与诊断
□ 掌握jps、jstat、jmap、jstack、jinfo等命令行工具
□ 了解JConsole、JVisualVM、MAT等图形化工具
□ 能够诊断内存泄漏问题
□ 能够诊断CPU使用率高的问题
□ 能够诊断频繁GC的问题

14.2 实践能力检查

实践能力检查清单

□ 代码分析能力
□ 能够分析代码的内存分配位置
□ 能够分析方法调用的栈帧变化
□ 能够分析对象的分配和晋升过程
□ 能够判断代码是否会发生OOM

□ 问题排查能力
□ 能够使用jstat监控GC情况
□ 能够使用jmap生成堆转储文件
□ 能够使用MAT分析堆转储文件
□ 能够使用jstack分析线程堆栈
□ 能够定位内存泄漏的代码位置

□ 参数调优能力
□ 能够根据应用特点设置堆大小
□ 能够根据对象特点设置新生代大小
□ 能够根据递归深度设置栈大小
□ 能够根据类数量设置元空间大小
□ 能够根据场景选择合适的GC收集器

□ 代码优化能力
□ 能够修复内存泄漏问题
□ 能够优化对象创建,减少GC压力
□ 能够使用对象池复用对象
□ 能够使用堆外内存减少GC影响
□ 能够分批处理大量数据

□ 工具使用能力
□ 熟练使用命令行工具
□ 熟练使用图形化工具
□ 能够编写内存监控工具
□ 能够编写性能分析脚本

14.3 面试准备检查

面试准备检查清单

□ 基础面试题
□ JVM运行时数据区有哪些?
□ 堆和栈的区别?
□ 什么是栈帧?栈帧包含哪些内容?
□ 程序计数器的作用是什么?
□ 为什么程序计数器不会OOM?

□ 进阶面试题
□ 永久代和元空间的区别?
□ 为什么要用元空间替代永久代?
□ 对象一定分配在堆上吗?
□ String s = new String("abc")创建了几个对象?
□ String.intern()方法的原理?

□ 高频面试题
□ 如何判断对象可以被回收?
□ Minor GC、Major GC、Full GC的区别?
□ 什么情况下会发生栈溢出?
□ 如何排查内存泄漏?
□ 如何优化JVM参数?

□ 项目经验
□ 能够描述项目中遇到的内存问题
□ 能够描述如何排查和解决问题
□ 能够描述JVM参数的配置和调优
□ 能够描述性能优化的经验

14.4 学习建议

学习建议

1. 理论学习
– 系统学习JVM运行时数据区的知识
– 理解各个区域的作用和原理
– 掌握内存分配和回收机制
– 学习JVM参数配置

2. 实践练习
– 编写代码验证理论知识
– 使用工具监控JVM运行状态
– 模拟各种OOM场景
– 练习排查和解决问题

3. 项目实战
– 在实际项目中应用所学知识
– 监控和优化项目的内存使用
– 排查和解决实际问题
– 总结经验和教训

4. 持续学习
– 关注JVM的新特性
– 学习新的GC收集器
– 阅读JVM相关书籍和文章
– 参与技术社区讨论

5. 面试准备
– 整理常见面试题
– 准备项目经验描述
– 练习口头表达
– 模拟面试场景

总结

运行时数据区是JVM的核心组成部分,深入理解运行时数据区对于Java开发者至关重要。通过本文档的学习,你应该掌握了:

  • JVM运行时数据区的完整结构和各区域的作用
  • 程序计数器、虚拟机栈、本地方法栈的工作原理
  • 堆内存的分代模型和对象分配流程
  • 方法区/元空间的演变和存储内容
  • 运行时常量池和字符串常量池的机制
  • 直接内存的使用场景和注意事项
  • 各种内存溢出的原因和解决方案
  • JVM参数配置和性能调优
  • 监控工具的使用和问题诊断方法
  • 继续深入学习JVM的其他知识点,如垃圾回收算法、垃圾收集器、类加载机制等,将帮助你成为一名优秀的Java开发者。

    赞(0)
    未经允许不得转载:171主机测评 » jvm运行时数据区
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址