jvm的位置

JVM（Java虚拟机）是Java程序的运行环境，它在计算机系统中处于一个特殊的位置。具体来说，JVM通常被安装在操作系统之上，但又位于应用程序之下。这种位置使得JVM能够在不同的操作系统上运行Java程序，实现了Java“一次编写，到处运行”的特性。

在计算机系统中，JVM通过解释Java字节码来执行Java程序。它负责将Java源代码编译成字节码，并在运行时将字节码转换为特定平台的机器码。这种中间层的设计使得Java程序具有跨平台的能力，因为JVM负责处理与底层操作系统和硬件的交互，从而隐藏了底层细节，使得Java程序能够在不同平台上运行。

jvm体系结构

JVM体系结构

JVM（Java虚拟机）的体系结构主要包括以下几个部分：

1. 类加载器（Class Loader）

类加载器负责加载Java类文件到JVM中，并生成对应的类对象。类加载器通常分为三种：启动类加载器、扩展类加载器和应用程序类加载器。它们按照一定的顺序来加载类文件，保证类的唯一性和安全性。

2. 运行时数据区

运行时数据区包括方法区、堆、栈、程序计数器和本地方法栈等。这些区域用于存储程序运行时的数据，如类信息、对象实例、方法信息等。

方法区：存储类的结构信息、静态变量、常量池等。
堆：存储对象实例。
栈：存储方法调用的局部变量、操作数栈、方法出口等。
程序计数器：记录当前线程执行的字节码指令地址。
本地方法栈：为本地方法服务。

3. 执行引擎

执行引擎负责执行字节码指令，将字节码翻译成机器码。执行引擎包括解释器、即时编译器（JIT）等，用于提高程序的执行效率。

4. 本地方法接口（Native Interface）

本地方法接口允许Java程序调用本地方法，实现Java和本地系统的交互。通过本地方法接口，Java程序可以调用C、C++等语言编写的本地方法。

5. 本地方法库

本地方法库包含了一系列本地方法的实现，供Java程序调用。这些本地方法通常由C、C++等语言编写，用于执行一些底层操作，如文件操作、网络通信等。

类加载器

类加载器（Class Loader）是JVM的一个重要组成部分，负责将Java类文件加载到内存中，并生成对应的类对象。在JVM体系结构中，类加载器扮演着关键的角色，保证了Java程序的正确运行和安全性。

类加载器的作用

加载：类加载器负责将.class文件加载到内存中，生成对应的类对象。
链接：链接阶段包括验证、准备和解析，类加载器在链接阶段执行相应的操作，如静态变量分配内存空间等。
初始化：类加载器负责执行类的初始化操作，包括执行静态代码块、初始化静态变量等。

类加载器的分类

启动类加载器（Bootstrap Class Loader）：负责加载Java的核心类库，如rt.jar等。
扩展类加载器（Extension Class Loader）：负责加载Java的扩展类库，如jre/lib/ext目录下的jar包。
应用程序类加载器（Application Class Loader）：负责加载应用程序的类，是最常用的类加载器。

类加载器的特点

双亲委派模型：类加载器采用双亲委派模型，即在加载类时，先委托父类加载器加载，只有在父类加载器无法加载时，才由子类加载器加载。
类加载器的层次结构：类加载器之间形成了层次结构，保证了类的唯一性和安全性。
动态加载：类加载器可以动态加载类，实现了Java程序的灵活性和可扩展性。

类加载器的重要性

类加载器是Java程序运行的基础，它负责将类文件加载到内存中，为程序的执行提供支持。良好的类加载器设计可以提高程序的性能和安全性，保证程序的稳定运行。

类加载器加载类的过程

类加载器（Class Loader）是Java虚拟机（JVM）的一个重要组成部分，负责将Java类文件加载到内存中，并生成对应的类对象。类加载器加载类的过程可以分为以下几个步骤：

加载（Loading）：类加载器首先通过类的全限定名（Fully Qualified Name）查找并定位到类文件的字节码数据。这个过程通常是从文件系统、网络或其他来源获取类文件的字节码数据。
链接（Linking）：链接阶段包括验证（Verification）、准备（Preparation）和解析（Resolution）三个步骤：
- 验证：验证阶段确保类文件的字节码符合JVM规范，不会危害JVM的安全性。
- 准备：准备阶段为类的静态变量分配内存空间，并设置默认初始值。
- 解析：解析阶段将类中的符号引用转换为直接引用，即将类、字段、方法的引用解析为直接引用。
初始化（Initialization）：在初始化阶段，类加载器执行类的初始化操作，包括执行静态代码块、初始化静态变量等。类的初始化是在必要时才进行的，如创建类的实例、访问类的静态变量或静态方法等。
生成类对象：当类加载器完成加载、链接和初始化阶段后，会生成对应的类对象，该类对象包含了类的方法、字段等信息，可以用于实例化对象或调用类的方法。

总的来说，类加载器加载类的过程包括加载、链接和初始化三个阶段，其中链接阶段又包括验证、准备和解析三个步骤。通过这个过程，类加载器能够将类文件加载到内存中，并为程序的执行提供必要的支持。

双亲委派模型

双亲委派模型是Java类加载器的一种工作机制，它通过一种层次结构的方式来加载类，保证类的唯一性和安全性。根据双亲委派模型，当一个类加载器需要加载一个类时，它会先委托其父类加载器加载，只有在父类加载器无法加载时，才由子类加载器加载。这种机制可以避免类的重复加载，同时防止恶意类的加载。

双亲委派模型的工作原理

当一个类加载器收到加载类的请求时，首先检查该类是否已经被加载过。
如果该类已经被加载过，直接返回已加载的类。
如果该类尚未被加载，类加载器会将加载请求委托给其父类加载器。
父类加载器会按照同样的方式继续向上委托，直到达到顶层的启动类加载器。
如果顶层的启动类加载器无法加载该类，便会逐级向下通知子类加载器进行加载。
如果所有的父类加载器都无法加载该类，最终由当前类加载器加载。

示例代码

// 自定义类加载器
public class CustomClassLoader extends ClassLoader {
    
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (!"java.lang.String".equals(name)) {
            return super.loadClass(name); // 委托父类加载器加载
        }
        
        try {
            String className = name.replace(".", "/") + ".class";
            InputStream is = getClass().getClassLoader().getResourceAsStream(className);
            byte[] classBytes = new byte[is.available()];
            is.read(classBytes);
            return defineClass(name, classBytes, 0, classBytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Class not found: " + name, e);
        }
    }
    
    public static void main(String[] args) {
        CustomClassLoader customClassLoader = new CustomClassLoader();
        try {
            Class<?> stringClass = customClassLoader.loadClass("java.lang.String");
            System.out.println("Class loaded by: " + stringClass.getClassLoader());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

在上面的示例代码中，自定义了一个类加载器CustomClassLoader，重写了loadClass方法。当加载类时，首先判断是否是java.lang.String类，如果不是，则委托父类加载器加载；如果是，则通过当前类加载器加载。通过这个示例代码可以看到双亲委派模型的工作原理。

沙箱安全机制

沙箱安全机制是一种用于保护计算机系统安全的技术手段，通过限制程序的运行环境和权限，防止恶意程序对系统造成危害。在Java中，沙箱安全机制被广泛应用于Java虚拟机（JVM）中，用于保护系统免受恶意代码的攻击。

沙箱安全机制的原理

限制资源访问权限：沙箱安全机制通过限制程序对系统资源的访问权限，如文件系统、网络、内存等，防止恶意程序对系统资源进行非法操作。
控制代码执行环境：沙箱安全机制可以控制程序的执行环境，如类加载器、运行时数据区等，确保程序在受控的环境中运行。
实现安全沙箱：通过安全沙箱的概念，将程序运行在受限制的环境中，限制程序的行为范围，防止其对系统造成危害。
权限控制：沙箱安全机制可以根据程序的权限需求，对程序进行权限控制，只允许程序在特定的权限范围内运行。

Java中的沙箱安全机制

在Java中，沙箱安全机制主要体现在以下几个方面：

类加载器限制：Java的类加载器采用双亲委派模型，通过层次结构的方式加载类，防止恶意类的加载，保证类的唯一性和安全性。
安全管理器：Java提供了安全管理器（Security Manager），用于控制程序对系统资源的访问权限，可以对程序的行为进行细粒度的控制。
沙箱策略：Java应用程序可以通过沙箱策略（Policy）来定义程序的权限范围，限制程序对系统资源的访问。
安全性检查：Java虚拟机在执行程序时会进行安全性检查，确保程序的行为符合沙箱安全机制的要求，防止恶意代码的执行。
安全沙箱：Java应用程序通常在受限制的安全沙箱中运行，限制程序的行为范围，防止其对系统造成危害。

沙箱安全机制的优势

系统安全性：沙箱安全机制可以保护系统免受恶意代码的攻击，确保系统的安全性。
资源隔离：沙箱安全机制可以实现资源隔离，防止程序对系统资源的滥用，保护系统资源的稳定性。
权限控制：沙箱安全机制可以对程序的权限进行控制，确保程序在受控的环境中运行，防止程序越权操作。
灵活性：沙箱安全机制可以根据程序的需求进行定制，灵活控制程序的行为范围，满足不同场景下的安全需求。

通过沙箱安全机制，Java程序可以在受限制的环境中运行，保护系统免受恶意代码的攻击，确保系统的安全性和稳定性。同时，沙箱安全机制也为程序的安全性提供了有效的保障，是保护系统安全的重要技术手段。

沙箱的基本组件

沙箱是一种用于保护计算机系统安全的技术手段，通过限制程序的运行环境和权限，防止恶意程序对系统造成危害。在Java中，沙箱安全机制主要由以下几个基本组件组成：

1. 字节码校验器（Bytecode Verifier）

字节码校验器是Java虚拟机（JVM）中的一个重要组件，用于确保Java程序的字节码符合JVM规范，不会危害JVM的安全性。字节码校验器主要包括以下几个方面的校验：

结构校验：确保字节码的结构符合JVM规范，如方法、字段、指令等的格式是否正确。
语义校验：检查字节码的语义是否合法，如类型转换、访问权限等。
数据流分析：通过数据流分析，检查字节码的操作是否合法，如变量的使用、赋值等。

字节码校验器通过对字节码进行严格的校验，防止恶意程序对系统造成危害，确保Java程序的安全性。

2. 类加载器（Class Loader）

类加载器是Java虚拟机中负责将Java类文件加载到内存中，并生成对应的类对象的组件。在沙箱安全机制中，类加载器扮演着关键的角色，保证了Java程序的正确运行和安全性。类加载器在三份方面对java沙箱起作用：

他防止恶意代码去干涉善意代码
它守护了被信任的类库边界
它将代码归入保护域，确定了代码可以执行哪些操作

3. 安全管理器（Security Manager）

安全管理器是Java中用于控制程序对系统资源的访问权限的组件。它可以对程序的行为进行细粒度的控制，确保程序在受控的环境中运行。安全管理器可以限制程序对系统资源的访问，如文件系统、网络、内存等，防止恶意程序对系统资源进行非法操作。

native关键字详解

在Java中，native关键字用于声明一个方法是由本地代码（如C、C++）实现的，即该方法的具体实现不是用Java语言编写的，而是通过本地方法接口（JNI）调用本地代码实现的。通过使用native关键字，Java程序可以调用本地方法，实现Java与本地系统的交互。

`native`关键字的作用

调用本地方法：native关键字声明的方法可以调用本地方法，实现Java程序与本地系统的交互。
提高性能：通过本地方法实现一些底层操作，可以提高程序的性能和效率。
访问系统资源：通过本地方法，可以访问系统资源，执行一些系统级操作。

使用`native`关键字的步骤

声明native方法：在Java代码中使用native关键字声明一个方法，表示该方法是由本地代码实现的。
编写本地方法实现：在本地代码（如C、C++）中实现声明的native方法。
使用JNI调用：通过JNI（Java Native Interface）调用本地方法，将Java程序与本地代码连接起来。

示例

public class NativeExample {
    // 声明native方法
    public native void nativeMethod();
    
    public static void main(String[] args) {
        NativeExample example = new NativeExample();
        // 调用native方法
        example.nativeMethod();
    }
    
    // 加载本地库
    static {
        System.loadLibrary("NativeLibrary");
    }
}

在上面的示例中，NativeExample类中声明了一个native方法nativeMethod()，并在main方法中调用了该方法。通过System.loadLibrary("NativeLibrary")加载本地库NativeLibrary，实现了Java程序与本地代码的连接。

注意事项

安全性：使用native关键字时需要注意安全性，确保本地方法的调用不会对系统造成危害。
跨平台性：由于本地方法是由本地代码实现的，需要注意跨平台兼容性，确保本地方法在不同平台上都能正确执行。
性能优化：使用native关键字时应注意性能优化，避免频繁调用本地方法导致性能下降。

通过native关键字，Java程序可以调用本地方法，实现与本地系统的交互，扩展了Java程序的功能和灵活性。

JNI接口详解

JNI（Java Native Interface）是Java提供的一种机制，用于实现Java程序与本地代码（如C、C++）的交互。通过JNI接口，Java程序可以调用本地方法，实现与本地系统的交互，扩展Java程序的功能和性能。

JNI接口的作用

调用本地方法：JNI接口允许Java程序调用本地方法，实现Java与本地代码的交互。
提高性能：通过JNI接口，Java程序可以调用本地代码实现一些性能敏感的操作，提高程序的执行效率。
访问本地资源：JNI接口可以访问本地系统资源，如文件系统、网络等，实现Java程序对本地资源的操作。

JNI接口的实现步骤

定义本地方法：在Java程序中使用native关键字声明本地方法。
生成头文件：使用javac命令生成包含本地方法声明的头文件。
实现本地方法：在本地代码中实现Java声明的本地方法。
生成动态链接库：将本地代码编译成动态链接库（.dll、.so等）。
加载动态链接库：在Java程序中加载动态链接库，并调用本地方法。

JNI接口的优势

跨平台性：通过JNI接口，Java程序可以调用本地方法，实现跨平台的功能。
性能优化：JNI接口可以调用本地代码，提高程序的性能和效率。
访问本地资源：JNI接口可以访问本地系统资源，扩展Java程序的功能。

JNI接口的注意事项

内存管理：在JNI接口中需要注意内存管理，避免内存泄漏和内存溢出。
类型转换：在Java和本地代码之间需要进行数据类型的转换，确保数据的正确传递。
异常处理：在JNI接口中需要处理异常，保证程序的稳定性和安全性。

通过JNI接口，Java程序可以与本地代码进行交互，实现更多功能和性能优化。JNI接口是Java程序扩展和优化的重要手段，为Java开发提供了更多可能性。

PC寄存器

PC寄存器（Program Counter Register）是计算机体系结构中的一个重要寄存器，用于存储当前线程正在执行的指令地址或下一条指令的地址。在不同的体系结构中，PC寄存器可能被称为指令指针寄存器（Instruction Pointer Register）或程序计数器（Program Counter）。

PC寄存器的作用

指令地址存储：PC寄存器存储当前线程正在执行的指令地址，指示下一条要执行的指令的位置。
指令跳转：当执行分支、跳转、函数调用等指令时，PC寄存器会更新为相应的目标地址，实现程序的控制流转移。
指令顺序控制：PC寄存器保证指令的顺序执行，确保程序按照正确的顺序执行指令。
异常处理：在发生异常或中断时，PC寄存器会保存异常处理程序的入口地址，以便程序跳转到相应的异常处理代码。

PC寄存器的特点

线程私有：每个线程都有自己的PC寄存器，用于存储该线程的指令地址。
指令地址宽度：PC寄存器的宽度取决于计算机体系结构，通常与地址总线的宽度相对应。
快速访问：PC寄存器是CPU内部的寄存器，用于快速访问当前指令地址，提高指令的执行效率。
指令流控制：PC寄存器控制程序的指令流，确保指令按照正确的顺序执行。

PC寄存器在Java虚拟机中的作用

在Java虚拟机（JVM）中，PC寄存器主要用于存储当前线程执行的字节码指令地址。由于Java是一种基于字节码的跨平台语言，JVM通过PC寄存器来控制字节码指令的执行，实现Java程序的跨平台特性。

PC寄存器在JVM中的作用包括：

指令解释：PC寄存器存储当前线程正在执行的字节码指令地址，用于解释执行Java程序。
指令跳转：当执行分支、跳转、循环等控制流指令时，PC寄存器更新为相应的目标地址，控制程序的执行流程。
异常处理：在Java程序中，异常处理机制依赖于PC寄存器保存异常处理程序的地址，以便在发生异常时跳转到相应的异常处理代码。
线程切换：在多线程环境下，PC寄存器存储每个线程的执行状态，实现线程切换时的上下文切换。

总的来说，PC寄存器在Java虚拟机中起着关键作用，控制Java程序的指令执行流程，保证程序的正确执行。通过PC寄存器，JVM能够实现Java程序的解释执行和跨平台特性。

JVM中的方法区（存储：static，final，Class，常量池）

方法区（Method Area）是Java虚拟机（JVM）的一部分，用于存储类的结构信息、静态变量、常量池等数据。方法区是线程共享的内存区域，每个线程都可以访问方法区中的数据。方法区在JVM规范中也被称为永久代（Permanent Generation），但在较新的JVM实现中，永久代已经被元空间（Metaspace）所取代。

静态变量、常量、类信息 (构造方法、接口定义)、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

方法区的特点

存储类的结构信息：方法区存储每个类的结构信息，包括类的方法、字段、构造函数等。
存储静态变量：方法区存储类的静态变量，这些变量在类加载时被初始化，并在整个程序运行期间保持不变。
存储常量池：方法区中包含常量池，用于存储类中的常量，如字符串常量、静态常量等。
存储方法字节码：方法区存储类的方法字节码，当方法被调用时，JVM会从方法区中获取对应的字节码进行执行。
线程共享：方法区是线程共享的内存区域，所有线程都可以访问方法区中的数据。

方法区的内部结构

方法区内部包括以下几个重要的部分：

运行时常量池：存储类中的常量，如字符串常量、静态常量等。
字段信息：存储类的字段信息，包括字段名称、类型、访问修饰符等。
方法信息：存储类的方法信息，包括方法名称、参数列表、返回类型、字节码等。
类的结构信息：存储类的结构信息，包括类的继承关系、实现接口、注解信息等。
静态变量：存储类的静态变量，这些变量在类加载时被初始化。

方法区的作用

方法区在Java虚拟机中扮演着重要的角色，具有以下几个作用：

存储类的结构信息：方法区存储每个类的结构信息，包括方法、字段、构造函数等，确保类的结构在程序运行期间可用。
存储静态变量：方法区存储类的静态变量，这些变量在类加载时被初始化，并在整个程序运行期间保持不变。
存储常量池：方法区中的常量池用于存储类中的常量，如字符串常量、静态常量等，提供了运行时常量池的支持。
存储方法字节码：方法区存储类的方法字节码，当方法被调用时，JVM会从方法区中获取对应的字节码进行执行。
支持反射：方法区中存储类的结构信息，支持Java的反射机制，使得程序可以在运行时获取类的信息、调用类的方法等。

方法区的内存管理

方法区的内存管理主要包括以下几个方面：

垃圾回收：方法区也会进行垃圾回收，主要针对无用的类、常量等进行回收，释放内存空间。
类的卸载：当一个类不再被程序使用时，方法区会对该类进行卸载，释放类的内存空间。
常量池的管理：方法区中的常量池需要进行管理，确保常量池中的数据有效且不重复。

方法区的变化

在较新的JVM实现中，方法区已经被元空间（Metaspace）所取代。元空间是一种与方法区功能类似的内存区域，它具有以下特点：

动态分配内存：元空间采用动态分配内存的方式，避免了方法区固定大小的限制。
与本地内存关联：元空间与本地内存关联，可以根据系统的实际内存情况动态调整大小。
垃圾回收：元空间也需要进行垃圾回收，释放无用的类、常量等占用的内存空间。

总的来说，方法区（或元空间）在Java虚拟机中扮演着重要的角色，负责存储类的结构信息、静态变量、常量池等数据，支持程序的正常运行和反射机制的实现。通过对方法区的管理和优化，可以提高程序的性能和稳定性。

栈（Stack）

栈是计算机科学中一种常见的数据结构，具有“先进后出”（Last In First Out，LIFO）的特性。栈可以看作是一种限制性的线性表，只允许在表的一端进行插入和删除操作，这一端通常称为栈顶。栈在计算机系统中有广泛的应用，其中在程序执行过程中，栈被用来存储方法调用、局部变量、操作数栈等信息。

栈的基本操作

栈的基本操作包括：

压栈（Push）：将元素压入栈顶，即插入元素到栈中。
弹栈（Pop）：从栈顶弹出元素，即删除栈顶元素。
获取栈顶元素（Top）：获取栈顶元素的值，不改变栈的状态。
判空（isEmpty）：判断栈是否为空。

栈的应用

1. 方法调用

在程序执行过程中，每次方法调用时，会将方法的参数、返回地址、局部变量等信息存储在栈中，形成一个方法调用栈。当方法执行完毕时，栈顶的方法信息会被弹出，控制权交给上一层方法。

2. 表达式求值

在编程语言中，表达式的求值通常使用栈来实现。通过将中缀表达式转换为后缀表达式，然后使用栈来存储操作数和运算符，依次计算得出表达式的结果。

3. 内存分配

在程序执行过程中，栈用于存储局部变量、方法参数等数据。当方法被调用时，会在栈中为方法分配内存空间，当方法执行完毕时，栈中的内存空间会被释放。

4. 递归调用

递归调用是一种方法调用自身的过程。在递归调用中，每次方法调用都会在栈中存储方法的信息，形成递归调用栈。当递归结束时，栈中的方法信息会被依次弹出。

栈的特点

后进先出（LIFO）：栈具有后进先出的特性，最后压入栈的元素最先弹出。
有限性：栈的大小通常是有限的，当栈空间不足时会发生栈溢出。
高效性：栈的操作通常是高效的，压栈、弹栈等操作的时间复杂度为O(1)。
局部性：栈中存储的数据具有局部性，只能访问栈顶元素，不支持随机访问。
线程安全：栈通常是线程安全的数据结构，因为每个线程都有自己的栈空间。

栈作为一种重要的数据结构，在计算机系统中有着广泛的应用。通过栈的特性，可以实现方法调用、表达式求值、内存分配等功能，为程序的执行提供支持。在编程中，合理地使用栈可以提高程序的效率和可读性。

Java方法的压栈出栈过程

在Java程序中，方法的执行过程涉及到方法调用栈（也称为调用栈或执行栈），它负责存储方法的调用信息和局部变量。

栈:

栈内存，主管程序的运行，生命周期和线程同步

线程结束，栈内存也就是释放，对于栈来说，

不存在垃圾回收问题

一旦线程结束，栈就Over!

栈存储的内容: 8大基本类型+对象引用+实例的方法

下面是Java方法的压栈出栈过程：

压栈过程

方法调用：当一个方法被调用时，会在调用栈中创建一个新的栈帧（Stack Frame），用于存储该方法的调用信息和局部变量。
栈帧压入：新创建的栈帧被压入调用栈的顶部，成为当前活动栈帧。
局部变量入栈：方法的局部变量被存储在当前栈帧的局部变量表中，包括方法参数、临时变量等。
方法执行：方法开始执行，按照程序逻辑执行相应的代码。

出栈过程

方法返回：当方法执行结束时，当前栈帧会被弹出调用栈，方法返回到调用点。
局部变量出栈：当前栈帧中的局部变量被释放，栈帧被销毁。
返回值传递：方法的返回值（如果有）被传递给调用点。
控制权返回：控制权返回到调用点，继续执行后续的代码。

栈溢出的原理

栈溢出是指调用栈中的栈帧数量超过了栈的容量，导致栈空间耗尽。栈溢出通常发生在以下情况：

递归调用过深：如果一个方法递归调用次数过多，会导致调用栈中的栈帧数量急剧增加，最终超出栈的容量。
无限循环调用：如果程序中存在无限循环调用的情况，也会导致调用栈中的栈帧数量不断增加，最终引发栈溢出。
大量局部变量：如果方法中定义了大量的局部变量，也会占用大量的栈空间，可能导致栈溢出。
过深的方法调用链：如果方法调用链过深，即方法的嵌套调用层级过多，也会增加调用栈中的栈帧数量，可能引发栈溢出。

当发生栈溢出时，通常会抛出StackOverflowError异常，表示调用栈溢出。为避免栈溢出，可以通过优化递归调用、减少局部变量占用等方式来控制调用栈的大小。

栈、堆和方法区的交互关系

在Java虚拟机（JVM）中，栈、堆和方法区是三个重要的内存区域，它们之间相互配合，共同支持Java程序的运行。它们之间的交互关系如下：

1. 栈与堆的交互

栈：栈是线程私有的内存区域，用于存储方法调用的局部变量、操作数栈、方法出口等。每个线程在执行方法时，都会创建一个对应的栈帧，栈帧中包含了方法的局部变量表、操作数栈等信息。栈的特点是先进后出，方法的调用和返回都在栈上进行。
堆：堆是线程共享的内存区域，用于存储对象实例。在堆中分配的对象实例可以被多个线程共享。当在方法中创建对象时，对象实例存储在堆中，而栈中存储的是对象的引用。栈中的引用指向堆中的对象实例，通过引用可以访问和操作堆中的对象。

栈中的局部变量表存储了基本数据类型和对象的引用，当方法调用时，会将方法的参数和局部变量存储在栈帧的局部变量表中。如果方法中创建了对象实例，对象实例存储在堆中，而栈帧的局部变量表中存储的是对象的引用。通过栈中的引用，可以访问和操作堆中的对象。

2. 栈与方法区的交互

栈：栈中除了存储局部变量表、操作数栈等信息外，还会存储方法的字节码指令地址。每个线程的栈帧中会记录当前执行的方法的字节码指令地址，用于指示下一条要执行的指令。
方法区：方法区用于存储类的结构信息、静态变量、常量池等。当一个线程执行方法时，会在方法区中查找并加载方法的字节码信息，包括方法的字节码指令、方法的参数和返回值等。方法区中的信息会被栈帧引用，栈帧中存储了方法的字节码指令地址，通过这个地址可以在方法区中找到对应的方法信息。

栈中的栈帧会引用方法区中的方法信息，栈帧中存储了当前执行方法的字节码指令地址，通过这个地址可以在方法区中找到对应的方法信息。方法区中存储了类的结构信息和方法的字节码指令，栈帧中的字节码指令地址指示了当前执行的方法在方法区中的位置。

3. 堆与方法区的交互

堆：堆中存储对象实例，对象实例的类信息和结构信息存储在方法区中。当在方法中创建对象时，对象实例存储在堆中，而对象的类信息、方法信息等存储在方法区中。
方法区：方法区存储类的结构信息、静态变量、常量池等。当在堆中创建对象实例时，对象的类信息和结构信息会被加载到方法区中。堆中的对象实例通过方法区中的类信息来获取方法的字节码指令、静态变量等信息。

堆中的对象实例通过方法区中的类信息来获取类的结构信息和方法信息。当在堆中创建对象时，对象的类信息会被加载到方法区中，堆中的对象实例通过方法区中的类信息来访问和操作类的结构和方法。

通过栈、堆和方法区之间的交互，Java程序能够在JVM中正常运行，实现了方法的调用、对象的创建和访问等功能。栈负责方法的调用和局部变量的存储，堆负责对象实例的存储，方法区负责类的结构信息和方法信息的存储，三者共同支持Java程序的执行。

Java内存中对象实例化的过程

在Java中，对象的实例化过程是通过类加载器将类加载到内存中，然后在堆内存中为对象分配内存空间，并调用构造方法初始化对象。下面是Java内存中对象实例化的详细过程：

加载类文件：首先，类加载器负责加载类文件到内存中。类加载器会根据类的全限定名（Fully Qualified Name）在类路径中查找对应的类文件，将类的字节码数据加载到内存中。
验证类文件：在加载类文件后，Java虚拟机会对类文件进行验证，确保字节码符合JVM规范，不会危害系统安全。
准备阶段：在准备阶段，Java虚拟机为类的静态变量分配内存空间，并设置默认初始值。这些静态变量会被初始化为默认值，如数值类型为0，引用类型为null。
解析阶段：在解析阶段，Java虚拟机将类中的符号引用转换为直接引用。符号引用是一种符号化的引用，直接引用是对应的内存地址。解析阶段将符号引用解析为直接引用，以便程序访问类、字段、方法等。
分配内存：在堆内存中为对象分配内存空间。堆内存是Java中存储对象实例的地方，通过new关键字创建对象时，会在堆内存中分配一块连续的内存空间。
初始化对象：在分配内存后，Java虚拟机会调用对象的构造方法对对象进行初始化。构造方法会初始化对象的实例变量，执行一些初始化操作，确保对象的正确状态。
对象引用：在对象实例化完成后，会返回一个对象引用（Reference），该引用指向堆内存中对象的内存地址。通过对象引用，程序可以访问和操作对象的实例变量和方法。

总的来说，Java内存中对象实例化的过程包括类加载、验证、准备、解析、内存分配和对象初始化等步骤。通过这个过程，Java程序可以在内存中创建对象实例，并对对象进行初始化，以便程序使用和操作对象。

多种jvm

HotSpot JVM（目前用的）

HotSpot JVM 是由 Oracle 公司开发的 Java 虚拟机实现，是目前使用最广泛的 JVM 之一。HotSpot JVM 通过即时编译（Just-In-Time Compilation）技术将 Java 字节码转换为本地机器码，以提高程序的执行效率。HotSpot JVM 包含了优化技术，如逃逸分析、方法内联、栈上替换等，用于优化程序的性能。HotSpot JVM 还具有自适应优化能力，可以根据程序的运行情况动态调整优化策略，提高程序的执行效率。

OpenJ9 JVM

OpenJ9 JVM 是由 Eclipse 基金会开发的 Java 虚拟机实现，具有优秀的内存管理和性能特性。OpenJ9 JVM 采用了高度优化的垃圾回收器，如增量式垃圾回收、压缩指针等，用于提高内存利用率和降低垃圾回收的停顿时间。OpenJ9 JVM 还支持 AOT（Ahead-Of-Time Compilation）编译技术，可以将 Java 字节码预先编译为本地机器码，以加速程序的启动和执行速度。OpenJ9 JVM 在云环境和大型应用程序中表现出色。

GraalVM

GraalVM 是由 Oracle 公司开发的一款全栈虚拟机，支持多种编程语言，包括 Java、JavaScript、Python 等。GraalVM 包含了 Graal 编译器，可以将 Java 字节码编译为高效的本地机器码，提高程序的执行性能。GraalVM 还支持原生图像处理、即时编译、多语言互操作等功能，使得开发人员可以在一个虚拟机环境中运行多种语言的应用程序。GraalVM 在性能和灵活性方面具有显著优势，适用于需要跨语言支持的场景。

JVM中的堆

在Java虚拟机（JVM）的运行时数据区中，堆（Heap）是一个重要的内存区域，用于存储对象实例和数组对象。堆是Java程序运行时动态分配内存的地方，所有的对象实例都在堆上分配内存。以下是关于JVM中堆的详细解释：

堆的特点

动态分配：堆是动态分配内存的区域，当需要创建新的对象实例时，堆会动态分配内存空间。
垃圾回收：堆中存储的对象实例由Java垃圾回收器负责回收，释放不再使用的内存空间。
线程共享：堆是所有线程共享的内存区域，不同线程可以共享堆中的对象实例。
自动内存管理：Java虚拟机负责管理堆的内存分配和释放，程序员无需手动管理堆内存。

堆的结构

堆可以分为三个部分：

新生代（Young Generation）：新生代是堆的一部分，用于存储新创建的对象实例。新生代又分为Eden区和两个Survivor区（From和To区）。
老年代（Old Generation）：老年代用于存储存活时间较长的对象实例，经过多次垃圾回收仍存活的对象会被移到老年代。
永久代（Permanent Generation）：永久代用于存储类的元数据信息、常量池等数据，从JDK 8开始被元空间（Metaspace）取代。

GC垃圾回收，主要是在伊甸园区和养老区-

假设内存满了，OOM，堆内存不够!java.lang.OutOfMemoryError: Java heap space

在JDK8以后，永久存储区改了个名字(元空间)

永久区（Permanent Generation）

永久区是Java虚拟机（JVM）运行时数据区的一部分，用于存储类的结构信息、静态变量、常量池等数据。在Java 8 及之前的版本中，永久区是存在的，但在 Java 8 中被元数据区（Metaspace）所取代。

这个区域常驻内存的。用来存放JDK自身携带的Class对象。Interface元数据，存储的是Java运行时的一些环境或类信息~，这个区域不存在垃圾回收!关闭虚拟机会释放内存

·jdk1.6 之前 : 永久代，常量池是在方法区

jdk1.7 ：永久代，但是慢慢的退化了，去永久代，常量池在堆中

jdk1.8之后 : 无永久代，常量池在元空间

一个启动类，加载了大量的第三方jar包。Tomcat部署了太多的应用，大量动态生成的反射类。不断的被加载。直到内存满，就会出现OOM;

以下是永久区的一些特点和作用：

特点

存储类的结构信息：永久区主要用于存储类的结构信息，包括类的方法、字段、构造函数等信息。
存储静态变量：静态变量被存储在永久区中，这些变量属于类而不是对象，因此存储在永久区中。
存储常量池：永久区还包括常量池，用于存储类中的常量，如字符串常量、静态常量等。

作用

支持类的加载和存储：永久区存储了类的结构信息，包括方法、字段等，支持类的加载和存储。
支持静态变量的存储：静态变量被存储在永久区中，保证了它们在整个程序运行期间的可访问性。
存储常量池：常量池中的常量被存储在永久区中，包括类中的字符串常量、静态常量等。

在 Java 8 及之前的版本中，永久区在 JVM 运行时起着重要的作用，但由于永久区的内存管理和性能问题，Java 8 引入了元数据区（Metaspace）来替代永久区。元数据区采用本地内存来存储类的元数据，避免了永久区的内存管理问题，提高了性能和可扩展性。

总的来说，永久区在 Java 8 及之前的版本中是 JVM 运行时数据区的一部分，用于存储类的结构信息、静态变量、常量池等数据，支持类的加载和存储，以及静态变量和常量池的存储。

元空间:逻辑上存在:物理上不存在

堆的内存分配

堆的内存分配主要包括以下几个阶段：

对象的创建：当程序创建新的对象实例时，堆会为对象分配内存空间。
内存分配指针碰撞：在堆中采用指针碰撞的方式进行内存分配，即堆空间被划分为已分配区域和未分配区域，通过一个指针来标记已分配区域的边界。
空闲列表：堆中也可以采用空闲列表的方式进行内存分配，即维护一个空闲内存块的列表，当需要分配内存时，从空闲列表中找到合适大小的内存块进行分配。

堆的调优

在Java应用程序中，可以通过调整堆的大小和参数来优化程序的性能和内存利用率。常见的堆调优参数包括：

-Xms：设置堆的初始大小。
-Xmx：设置堆的最大大小。
-Xmn：设置新生代的大小。
-XX:NewRatio：设置新生代和老年代的比例。
-XX:SurvivorRatio：设置Eden区和Survivor区的比例。
-XX:+PrintGcDetails：打印信息
XX:+HeapDumpOnOutOfMemoryError：dump文件

通过以上命令，可以根据实际情况调整堆内存的大小，从而优化Java应用程序的性能。

通过合理调整堆的大小和参数，可以提高程序的性能和稳定性，避免内存溢出等问题。

总的来说，堆是Java虚拟机中用于存储对象实例的重要内存区域，具有动态分配、垃圾回收、线程共享等特点。了解堆的结构和内存分配方式，以及通过调优参数来优化堆的性能，对于Java程序的开发和性能调优都具有重要意义。

堆内存调优命令

为了优化Java应用程序的性能，可以通过调整堆内存的大小来提高程序的运行效率。以下是常用的堆内存调优命令：

设置初始堆大小和最大堆大小
```
java -Xms<size> -Xmx<size> <MainClass>
```
其中，-Xms 用于设置初始堆大小，-Xmx 用于设置最大堆大小。<size> 可以是以 k 或 K 结尾的整数（表示KB）、以 m 或 M 结尾的整数（表示MB）、以 g 或 G 结尾的整数（表示GB）。
示例：
```
java -Xms512m -Xmx1024m MyApp
```
这个命令将设置初始堆大小为512MB，最大堆大小为1024MB。
设置新生代和老年代的大小
```
java -Xmn<size> -XX:MaxTenuringThreshold=<threshold> <MainClass>
```
其中，-Xmn 用于设置新生代的大小，-XX:MaxTenuringThreshold 用于设置对象晋升到老年代的年龄阈值。
示例：
```
java -Xmn256m -XX:MaxTenuringThreshold=15 MyApp
```
这个命令将设置新生代的大小为256MB，对象晋升到老年代的年龄阈值为15。
设置永久代大小
```
java -XX:PermSize=<size> -XX:MaxPermSize=<size> <MainClass>
```
其中，-XX:PermSize 用于设置永久代的初始大小，-XX:MaxPermSize 用于设置永久代的最大大小。
示例：
```
java -XX:PermSize=128m -XX:MaxPermSize=256m MyApp
```
这个命令将设置永久代的初始大小为128MB，最大大小为256MB。

在一个项目中，突然出现了OOM故障，那么该如何排除~研究为什么出错

能够看到代码第几行出错:内存快照分析工具，MAT，Jprofiler

。Dubug，一行行分析代码!

MAT, Jprofiler 作用

分析Dump内存文件，快速定位内存泄露;

。获得堆中的数据

获得大的对象~

排查 Java 内存溢出（OOM）异常

当项目中出现 Java 内存溢出（OOM）异常时，可以通过以下步骤进行排查和研究：

1. 分析异常信息

首先，查看异常堆栈信息，了解异常发生的位置和原因。通常 OOM 异常会包含详细的堆栈信息，可以从中找到异常发生的代码位置和可能的原因。

2. 查看堆内存使用情况

使用 Java 监控工具（如 JVisualVM、VisualVM、JConsole 等）或者命令行工具（如 jstat、jmap、jcmd 等）查看项目的堆内存使用情况，包括堆内存大小、已使用内存、垃圾回收情况等。

3. 分析内存泄漏

检查是否存在内存泄漏的情况，即某些对象被错误地保留在内存中而无法被释放。可以通过内存分析工具（如 Eclipse Memory Analyzer、YourKit Java Profiler 等）来分析内存快照，查找可能的内存泄漏问题。

4. 检查代码中的资源释放

检查代码中是否存在未正确释放的资源，如文件、数据库连接、网络连接等。确保在使用完资源后及时释放，避免资源占用过多内存。

5. 分析对象生命周期

分析项目中对象的生命周期，查看是否存在长时间存活的对象或者大量短期对象频繁创建的情况。优化对象的创建和销毁过程，避免内存占用过多。

6. 调整 JVM 参数

根据项目的实际情况，调整 JVM 的内存参数，如堆内存大小、永久代大小、新生代大小等，以及垃圾回收策略，优化内存使用情况。

7. 进行压力测试

如果可能，进行压力测试，模拟项目的高负载情况，观察内存使用情况，找出可能导致 OOM 异常的原因。

8. 代码审查和优化

对项目中的关键代码进行审查和优化，尤其是涉及大量内存操作的部分，优化算法和数据结构，减少内存占用。

9. 使用日志和监控工具

在项目中添加日志和监控工具，记录内存使用情况和关键操作，及时发现内存异常并进行处理。

通过以上步骤，可以全面地排查和研究项目中出现的 OOM 异常，找出异常的原因并进行相应的优化和调整，以避免类似问题的再次发生。

GC

GC（垃圾回收）是Java虚拟机（JVM）中用于自动管理内存的一种机制。它负责回收不再被使用的对象，释放内存以供新对象使用。GC的核心在于识别并清除那些不再被引用的对象，从而避免内存泄漏和优化内存使用。

GC作用区是堆和方法区

JVM 在进行GC时，并不是对这三个区域统一回收。大部分时候，回收都是新生代-

GC的工作流程

垃圾回收触发：当堆内存达到一定阈值，JVM会触发GC。
执行GC算法：根据使用的GC算法进行垃圾回收。
整理内存：如果使用了标记-整理算法，会将活跃对象整理到堆的一端。
更新引用：更新对象的引用，确保程序在GC后能正常运行。

GC的类型

Minor GC：对新生代和的垃圾回收，发生频繁。
Major GC（或Full GC）：对老年代和整个堆的垃圾回收，发生频率较低，但通常需要更多的时间。

垃圾回收（GC）算法详解

1. 引用计数法（Reference Counting）

引用计数法通过维护每个对象的引用计数来管理内存。每当有引用指向对象时，引用计数加1；当引用被取消时，计数减1。当计数为0时，对象被回收。此方法的优点是可以及时回收对象，但缺点是无法处理循环引用的问题。

2. 标记-清除算法（Mark and Sweep）

标记-清除算法分为两个阶段：

标记阶段：遍历所有可达对象，从根节点开始标记所有活动的对象。
清除阶段：扫描堆中所有对象，回收那些没有被标记的对象。

这种算法简单且实现容易，但会导致内存碎片化。

优点:不需要额外的空间!

缺点:两次扫描，严重浪费时间，会产生内存碎片

3. 标记-压缩算法（Mark and Compact）

标记-压缩算法包括：

标记阶段：同标记-清除算法，标记所有活动对象。
压缩阶段：将标记的对象移动到堆的一端，更新引用指向新的对象位置，释放未使用的内存区域。

此方法有效解决了内存碎片问题，但需要额外的移动操作和更新引用。

标记清除压缩：标记清除几次再进行压缩

4. 复制算法（Copying）

复制算法将内存分为两部分，活动区域和空闲区域：

复制阶段：将活动对象从当前区域复制到空闲区域。
回收阶段：当前区域的所有对象都被回收，腾出空间。

该算法通过复制和整理内存有效减少碎片化问题，但需要额外的空间用于复制。

复制算法最佳使用场景:对象存活度较低的时候;新生区

引用计数法示例代码

class ReferenceCountingGC {
    public Object instance = null;
    private static final int _1MB = 1024 * 1024;
    private byte[] bigSize = new byte[2 * _1MB];

    public static void main(String[] args) {
        ReferenceCountingGC objA = new ReferenceCountingGC();
        ReferenceCountingGC objB = new ReferenceCountingGC();
        objA.instance = objB;
        objB.instance = objA;

        objA = null;
        objB = null;

        // 在引用计数法中，objA和objB的引用计数为2，但它们互相引用，导致引用计数不为0，无法被回收。
    }
}

标记清除算法示例代码

class Node {
    Node next;
}

public class MarkAndSweepGC {
    public static void main(String[] args) {
        Node head = new Node();
        Node node1 = new Node();
        Node node2 = new Node();

        head.next = node1;
        node1.next = node2;
        node2.next = null;

        // 在标记清除算法中，从根节点head开始标记可达对象，然后清除不可达对象node1和node2。
    }
}

标记压缩算法示例代码

class TreeNode {
    TreeNode left;
    TreeNode right;
}

public class MarkAndCompactGC {
    public static void main(String[] args) {
        TreeNode root = new TreeNode();
        TreeNode node1 = new TreeNode();
        TreeNode node2 = new TreeNode();

        root.left = node1;
        root.right = node2;

        // 在标记压缩算法中，标记可达对象后，将可达对象压缩到内存的一端，释放不可达对象占用的内存空间。
    }
}

复制算法示例代码

class Memory {
    private static final int _1MB = 1024 * 1024;
    private byte[] space = new byte[2 * _1MB];

    public static void main(String[] args) {
        Memory memory = new Memory();
        // 在复制算法中，将内存空间分为两块，每次只使用其中一块，当一块内存空间用完时，将存活对象复制到另一块内存空间中，同时清理已死对象。
    }
}

总结

内存效率:复制算法>标记清除算法>标记压缩算法(时间复杂度)

内存整齐度:复制算法=标记压缩算法>标记清除法

内存利用率:标记压缩算法=标记清除法>复制算法

思考一个问题:难道没有最优算法吗?

没有，没有最好的算法，只有最合适的

GC:分代收集算法

年轻代:

存活率低
复制算法!

老年代:

区域大:存活率
标记清除(内存碎片不是太多)+标记压缩混合实现

GC: 分代收集算法详解

垃圾回收（GC，Garbage Collection）是Java虚拟机（JVM）管理内存的核心机制之一。分代收集算法是一种重要的垃圾回收策略，旨在提高垃圾回收的效率。这个算法将堆内存划分为不同的区域，根据对象的生命周期将其分配到不同的区域中，从而优化回收过程。以下是对分代收集算法的详细解析。

分代收集算法概述

分代收集算法将堆内存分为几个不同的区域，这些区域通常包括：

年轻代（Young Generation）：存放新创建的对象。年轻代又分为三个区域：
- Eden 区：大多数对象首先分配在这里。
- Survivor 0 区（S0 区）：一个幸存区域，用于存放从 Eden 区复制过来的对象。
- Survivor 1 区（S1 区）：另一个幸存区域，与 S0 区交替使用。
老年代（Old Generation）：存放生命周期较长的对象。经过多次垃圾回收后，仍然存活的对象将被移动到老年代。
永久代（Permanent Generation）（在 JDK 8 之前的版本）：存放类的元数据、常量池等。在 JDK 8 之后，永久代被替换为元空间（Metaspace）。

分代收集的基本原则

分代收集算法的核心思想是根据对象的生命周期将对象划分到不同的区域。以下是分代收集算法的一些基本原则：

短生命周期对象频繁产生：年轻代中对象的生命周期通常较短，频繁创建和销毁。大多数对象在年轻代中被快速回收。
长期存活对象少：虽然年轻代中对象的生命周期短，但经过多次垃圾回收仍然存活的对象可能具有较长的生命周期，这些对象会被移动到老年代。
回收效率差异：年轻代的回收频率较高，但由于对象较少且生命周期较短，回收速度较快。老年代的回收相对较少，回收过程也更复杂，但回收的对象通常较多且生命周期较长。

年轻代的垃圾回收

年轻代的垃圾回收主要采用复制算法。该算法的基本步骤如下：

标记和清除：垃圾回收器会扫描 Eden 区中的对象，标记出存活的对象，并将其复制到 S0 区或 S1 区。
整理：清除 Eden 区中的所有对象（无论是否存活），然后将幸存的对象从 S0 区或 S1 区复制到另一个空闲的幸存区。
交替：在下一次垃圾回收时，交换 S0 区和 S1 区的角色。即原来的 S0 区成为 S1 区，原来的 S1 区成为新的空闲区，用于存放新的幸存对象。

老年代的垃圾回收

老年代的垃圾回收主要采用标记-整理或标记-压缩算法。该算法的基本步骤如下：

标记：首先标记出所有存活的对象。这一过程可能会涉及到整个老年代的扫描。
整理：将所有存活的对象移动到堆的一个端点，并整理出一个连续的空闲空间。这有助于提高内存的利用率并减少碎片。
回收：清理掉标记为垃圾的对象，释放其占用的内存空间。

收集过程中的各阶段

Minor GC（年轻代垃圾回收）：
- 触发条件：当年轻代的 Eden 区满时。
- 执行内容：回收年轻代中的对象，将幸存的对象移动到幸存区（S0 或 S1）。
Full GC（全堆垃圾回收）：
- 触发条件：老年代或年轻代的空间不足时，或在系统运行时需要更多内存时。
- 执行内容：回收整个堆中的所有对象，包括年轻代和老年代。此过程较为耗时，因为需要扫描整个堆的所有区域。

垃圾回收的优化

为了提高垃圾回收的效率和减少对应用性能的影响，JVM 提供了多种垃圾回收器和优化策略：

并行垃圾回收器：使用多线程来提高垃圾回收的速度，如 Parallel GC。
并发垃圾回收器：在应用线程执行的同时进行垃圾回收，如 Concurrent Mark-Sweep (CMS) 和 G1 GC。
增量垃圾回收器：在进行垃圾回收时，将工作负载分成多个小的阶段，以减少对应用的暂停时间，如 G1 GC。

通过适当的垃圾回收策略和优化设置，可以提高应用程序的性能，减少垃圾回收对系统的影响。分代收集算法通过将对象生命周期分层管理，优化了垃圾回收过程，使得大多数情况下垃圾回收能够更高效地进行。

Java内存模型（Java Memory Model）

Java内存模型（JMM）定义了Java程序中多线程并发访问共享内存时的行为规范，确保多线程程序在不同平台上表现一致性。JMM主要规定了线程之间如何进行通信、内存如何分配以及如何保证内存可见性等方面的规则，以确保多线程程序的正确性和可靠性。

JMM的基本特性

主内存与工作内存：JMM将内存分为主内存和工作内存两部分。主内存是所有线程共享的内存区域，而每个线程都有自己的工作内存，线程的操作都在工作内存中进行，然后同步到主内存中。
内存可见性：JMM通过内存屏障（Memory Barrier）来保证内存可见性，即一个线程对共享变量的修改对其他线程可见。
原子性：JMM通过锁和同步机制来保证对共享变量的操作是原子性的，即不会被其他线程中断。
有序性：JMM通过内存屏障来保证指令的有序性，即指令不会乱序执行，保证程序的执行顺序符合预期。

JMM的内存模型

JMM定义了一套内存模型，用于描述线程之间如何访问共享内存。JMM的内存模型主要包括以下几个部分：

主内存（Main Memory）：所有线程共享的内存区域，包含所有的共享变量。
工作内存（Working Memory）：每个线程独有的内存区域，包含了线程独占的变量副本以及共享变量的副本。
内存屏障（Memory Barrier）：用于保证内存可见性和指令有序性的机制，包括读屏障、写屏障和全屏障。
happens-before关系：描述了两个操作之间的执行顺序关系，用于确定操作之间的先后顺序。
volatile关键字：用于声明共享变量，保证对该变量的读写操作具有内存可见性。

JMM的操作规则

JMM定义了一些操作规则，用于确保多线程程序的正确性：

原子性规则：对基本数据类型的读取和赋值操作具有原子性。
可见性规则：一个线程对共享变量的修改对其他线程可见。
有序性规则：程序的执行顺序按照代码的顺序执行，不会乱序执行。
volatile变量规则：对volatile变量的读写操作具有内存可见性。
锁规则：对一个锁的解锁操作对其他线程的加锁操作可见。

JMM的应用

JMM的规范对Java程序员来说是透明的，但在编写多线程程序时需要遵循JMM的规则，以确保程序的正确性。合理地使用锁、volatile关键字和其他同步机制可以避免多线程并发访问共享内存时出现的问题，提高程序的性能和可靠性。

总的来说，JMM是Java多线程编程的基础，了解JMM的内存模型和操作规则有助于编写高效、正确的多线程程序。通过遵循JMM的规范，可以避免多线程并发访问共享内存时可能出现的问题，确保程序的正确性和可靠性。

If you find the article useful, feel free to appreciate

jvm基础（一）

https://blog.mykele.asia/archives/jvmji-chu-yi

Author

kele

Published on

2024-09-13

Updated on

2024-09-17

License

CC BY 4.0