JAVA理论第五章-JVM

1. 局部变量表（存放基本数据类型、和引用数据类型在堆中的地址、方法的返回地址）
2. 操作数栈：存放计算过程中的中间结果，同时作为计算过程中变量临时的存储空间
3. 动态连接：一个指向运行时常量池中该栈帧所属方法的引用
4. 方法出口：记录方法结束后，继续运行下一个栈帧对应方法那行代码
5. 栈帧：栈的最小单位，用来表达方法与方法之间的调用关系

1. 程序计数器（属于栈）
2. 本地方法栈（属于栈）
3. java虚拟机栈（属于栈）
4. 堆

1. 元数据区
2. 直接内存

1. 永久代属于JVM堆的一部分、有固定大小，性能更差
2. 元空间属于本地内存、能动态扩容、性能更好

1. 虚拟机栈中引用的对象
2. 本地方法栈引用的对象
3. 方法区中静态属性引用的对象
4. 方法区中常量引用的对象

1. 所有新生成的的对象首先都是放在年轻代
2. 新生代内存按照8：1：1的比例分为了一个Eden区和两个Survivor(survivor0,survivor1)区、也叫幸存者区。大部分对象在Eden区中生成。回收时先将eden区存活对象复制到survivor0区，然后清空eden区，当这个survivor0区也存满时，则将eden区和survivor0区存活的对象复制到另一个survivor1区，然后清空eden区和幸存者0区，此时幸存者0区就是空的，然后将幸存者0区和幸存者1区交换内存，则保持幸存者1区为空，如此循环操作。
3. 当幸存者1区不足以存放eden区和幸存者0区的存活对象的时候，就将存活对象直接放到老年代，若是老年代也满了就会触发一次Major GC,也就是新生代和老年代都进行垃圾回收。
4. 新生代发送的GC叫Minor GC ，MinorGc发送频率比较高（不一定等Eden区满了才触发）

1.垃圾回收是否涉及栈内存

垃圾回收主要指就是堆内存，当栈帧弹栈以后，内存就会释放

2.栈内存分配越大越好吗？

不一定，默认的栈内存通常为1024k

栈帧过大会导致线程数变少，例如，机器总内存为512m，目前能活动的线程数则为512个，如果把栈内存改为2048k，那么能活动的栈帧就会减半

3.方法内的局部变量是否线程安全？

1. 如果方法内局部变量没有逃离方法的作用范围（即没有将局部变量return出去），它是线程安全的
2. 如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

public class ThreadSafeDemo {
    public static void main(String[] args) {
        // 创建共享的 StringBuilder 对象
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        
        // 启动新线程操作共享的 sb，m2 中对共享资源操作无同步，线程不安全
        new Thread(() -> {
            m2(sb);
        }).start();
    }

    // m1 方法：
    // 线程安全。因为 StringBuilder 是方法内局部变量，每个线程调用 m1 时会创建独立的 sb，不存在多线程共享
    public static void m1() {
        StringBuilder sb = new StringBuilder(); 
        sb.append(1);
        sb.append(2);
        System.out.println(sb.toString());
    }

    // m2 方法：
    // 线程不安全。参数 sb 是多线程共享的（main 线程和新启动线程共用），append 操作非原子且无同步，可能导致线程间干扰
    public static void m2(StringBuilder sb) {
        sb.append(3);
        sb.append(4);
        System.out.println(sb.toString());
    }

    // m3 方法：
    // 线程不安全。虽然 StringBuilder 是局部变量，但方法返回其引用后，若外部多线程获取该引用并操作，会引发线程安全问题（如共享引用被修改）
    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(5);
        sb.append(6);
        return sb; 
    }
}

4.栈内存溢出情况

1. 栈帧过多导致栈内存溢出，典型问题：递归调用

1. 栈帧过大导致栈内存溢出

5.堆栈的区别是什么？

1. 栈内存一般用来存储局部变量和方法调用，但堆内存是用来存储java对象和数组的。堆会GC垃圾回收，而栈不会
2. 栈内存是线程私有的，而堆内存是线程共有的
3. 两者异常错误不同，但如果栈内存或者堆内存不足都会抛出异常。
   1. 栈空间不足：java.lang.StackOverFlowError。
   2. 堆空间不足：java.lang.OutOfMemoryError。

什么是类加载器，类加载器有哪些？

1. 什么是类加载器

JVM只会运行二进制文件，类加载器的作用就是将字节码文件加载到JVM中，从而让java程序能够启动起来

2.类加载器有哪些？

1. 启动类加载器（BootStrap ClassLoader）：加载JAVA_HOME/jre/lib目录下的库
2. 扩展类加载器（ExtClassLoader）：主要加载JAVA_HOME/jre/lib/ext目录中的类
3. 应用类加载器（AppClassLoader）：用于加载classPath下的类
4. 自定义类加载器（CustomizeClassLoader）：自定义类继承ClassLoader，实现自定义类加载规则

双亲委派模型

什么是双亲委派模型？

加载某一个类，先委托上一级的加载器进行加载，如果上级加载器也有上级，则会继续向上委托，如果该类委托上级没有被加载，子加载器尝试加载该类。

如果加载的类在上级找到，则子加载器不用加载，例如String类。即优先使用JDK原生的类

JVM为什么采用双亲委派机制？

1. 通过双亲委派机制可以避免某一个类被重复加载，当父类已经加载后则无需重复加载，保证唯一性。
2. 为了安全，保证类库API不会被修改

由于是双亲委派机制，java.lang.String的在启动类加载器得到加载，因为在核心jre库中有其相同名字的类文件，但该类中并没有main方法。这样就能防止恶意篡改核心API库

类装载的执行过程

类从加载到虚拟机中开始，直到卸载为止，它的整个生命周期包括了：加载、验证、准备、解析、初始化、使用和卸载这7个阶段。其中，验证、准备和解析这三个部分统称为连接（linking）

加载

1. 通过类的全名，获取类的二进制数据流
2. 解析类的二进制数据流为方法区内的数据结构（Java类模型）
3. 创建java.lang.Class类的实例，表示该类型。作为方法区这个类的各种数据的访问入口

连接

验证

验证类是否符合JVM规范，安全性检查

1. 格式检查，如：文件格式是否错误，语法是否错误、字节码是否合规
   1. 文件格式验证
   2. 元数据验证
   3. 字节码验证
2. 符号引号验证：Class文件在其常量池会通过字符串记录自己将要使用的其他类或者方法，检查他们是否存在

准备

为类变量分配内存并设置类变量初始值

1. static变量，分配空间在准备阶段完成（设置默认值），赋值在初始化阶段完成
2. static变量是final的基本类型，以及字符串常量，值已确定，赋值在准备阶段完成
3. static变量是final的引用类型，那么赋值也会在初始化阶段完成

解析

把类中的符号引用转换为直接引用

比如：方法中调用了其他方法，方法名可以理解为符号引用，而直接引用就是使用指针直接指向方法。

初始化

对类的静态变量，静态代码块执行初始化操作

1. 如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类
2. 如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行

使用

JVM开始入口开始执行用户的程序代码

1. 调用静态类成员信息（比如：静态字段、静态方法）
2. 使用new关键字为其创建对象实例

总结

1. 加载：查找和导入class文件
2. 验证：保证加载类的准确性
3. 准备：为类变量分配内存并设置类变量初始值
4. 解析：把类中的符号引用转换为直接引用
5. 初始化：对类的静态变量，静态代码块执行初始化操作
6. 使用：jvm开始从入口方法开始执行用户的程序代码
7. 卸载：当用户程序代码执行完毕后，JVM便开始销毁创建的class对象

强引用、软引用、弱引用、虚引用的区别

1. 强引用：被仍一GC Roots对象【强引用】的对象，该对象都不会被垃圾回收

User  user =new User()

2.软引用：仅有软引用该对象时，在垃圾回收后，如果内存仍不足会再次触发垃圾回收

User user = new User();
SoftReference softReference = new SoftReference(user);

需要配合WeakReference（弱引用）使用

User user = new User();
ReferenceQueue queue = new ReferenceQueue();
PhantomReference phantomReference = new PhantomReference(user, queue);