-
虚拟机栈：八大基本类型的数据、对象引用和实例的方法；
-
本地方法栈：与虚拟机栈作用相似，区别在于虚拟机栈为虚拟机执行 Java 方法服务，而本地方法栈是为虚拟机使用到的 native 方法服务；
-
堆：存放几乎所有的对象实例、数组；
-
方法区：类信息（包括常量池）、常量、静态变量、即时编译器编译后的代码；
-
常量池：类信息中除了有类的版本、字段、⽅法、接⼝等描述信息外，还有⽤于存放编译期⽣成的各种字⾯量和符号引⽤的常量池表。
1 什么是 JVM
JVM 是运行 Java 字节码的虚拟机，它是 Java 的核心内容，它有针对不同系统的特定实现，使得相同的字节码在不同的系统上可以得到相同的结果，从而保证 Java 跨平台性。
2 JVM 的内存结构
JVM 主要由线程私有的虚拟机栈、本地方法栈、程序计数器和线程共享的堆和方法区组成。
-
虚拟机栈描述的是 Java 方法执行的内存模型。它实际上是由一个个栈帧组成的，每一个方法从调用至执行完成的过程，都对应着一个栈帧在虚拟机栈里从入栈到出栈的过程。
-
本地方法栈的话与虚拟机栈作用类似，区别在于虚拟机栈为虚拟机执行 Java 方法服务，而本地方法栈是为虚拟机使用到的 native 方法服务。
-
程序计数器的主要由两个作用：
-
字节码解释器通过程序计数器来依次读取指令，从⽽实现代码的流程控制；
-
在多线程的情况下，程序计数器⽤于记录当前线程执⾏的位置。
-
堆用来存放对象实例，几乎所有的对象实例以及数组都在这里分配内存；
-
方法区是各个线程共享的内存区域，它⽤于存储已被虚拟机加载的类信息（常量池）、常量、静态变量、即时编译器编译后的代码等数据。
=========================================================================
类加载器负责将 Java 类动态地加载到虚拟机中并转换成对应的实例，第一次使用该类时才加载。 Java 类的虚拟机使用 Java 方式如下：Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件），类加载器负责读取 Java 字节代码，并转换成 java.lang.Class类的一个实例。
下面用代码来说明类加载器：
public class Test{
public static void main(String[] args) {
// 类的对象
Person zhao = new Person();
Person li = new Person();
Person pan = new Person();
// 不同的对象的哈希值不同
System.out.println(zhao.hashCode());
System.out.println(li.hashCode());
System.out.println(pan.hashCode());
// 从类的对象得到对应的类型
Class<? extends Person> zhaoClass = zhao.getClass();
Class<? extends Person> liClass = li.getClass();
Class<? extends Person> panClass = pan.getClass();
// 因为是同一个类型，所以哈希值相同
System.out.println(zhaoClass.hashCode());
System.out.println(liClass.hashCode());
System.out.println(panClass.hashCode());
// 得到类的类加载器
ClassLoader classLoader = zhaoClass.getClassLoader();
// AppClassLoader
System.out.println(classLoader);
// PlatformClassLoader
System.out.println(classLoader.getParent());
// null
System.out.println(classLoader.getParent().getParent());
}
}
class Person{
String name;
int age;
}
1） 定义
当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载且无法加载，自己才会去加载这个类。
2） 类加载器的类别
-
BootstrapClassLoader（启动类加载器）：
c++编写，加载java核心库java.*,构造ExtClassLoader和AppClassLoader。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作； -
ExtClassLoader （标准扩展类加载器）：
java编写，加载扩展库，如classpath中的jre，javax.*或者
java.ext.dir 指定位置中的类，开发者可以直接使用标准扩展类加载器；
-
AppClassLoader（系统类加载器）：java
编写，加载程序所在的目录，如user.dir所在的位置的class； -
CustomClassLoader（用户自定义类加载器）：
java编写,用户自定义的类加载器,可加载指定路径的class文件。
3） 委派机制的流程图
4） 双亲委派机制的作用
-
防止重复加载同一个
.class。通过委托去向上面问一问，加载过了，就不用再加载一遍。保证数据安全； -
保证核心
.class不能被篡改。通过委托方式，不会去篡改核心.class，即使篡改也不会去加载，即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个Class对象。这样保证了Class执行安全。
参考文献：传送门
1） 定义
Java 安全模型的核心就是 Java 沙箱（sandbox），什么是沙箱？沙箱是一个限制程序运行的环境。沙箱机制就是将 Java 代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。
-
双亲委派机制-保证 JVM 不被加载的代码破坏；
-
沙箱安全机制-保证机器资源不被 JVM 里运行的程序破坏。
2） 基本组件
-
字节码校验器：确保 Java 文件遵循 Java 语言规范等，字节码校验器在编译过程就会报错，不需要到运行过程；
-
类加载器：通过双亲委派机制；
-
内置于 Java 虚拟机（及语言）的安全特性；
-
安全管理器及 Java API。
参考文献：传送门
-
加载：通过类加载器把 class 字节码文件载入到内存中；
-
验证：保证加载进来的字节码文件符合虚拟机规范，不会造成安全错误。
-
准备：为静态变量以及常量分配内存，并赋予初值；
-
解析：将常量池内的符号引用替换为直接引用；
-
初始化：对静态变量或者语句进行初始化；
类加载过程是类生命周期的一部分，在这个过程之前，还有源代码的编译，在这个过程之后，还有垃圾回收等。
参考文献：传送门
1 面试：Java 创建对象的过程
-
类加载检查：判断这个类是否被加载过，如果还没未被加载，则先进行类的加载、解析和初始化过程。
-
分配内存：类加载检查通过后，虚拟机会在堆中为新生对象分配内存；
-
初始化零值：，虚拟机将分配到的内存空间，除了对象头，都初始化为零值；
-
设置对象头：将对象的哈希码等信息放到对象头中；
-
执行初始化方法：比如通过构造方法将对象按照程序员的意愿进行初始化。
Java 对象的创建过程如下图所示：
-
类加载检查：当虚拟机遇到一条 new 指令时，先检查这个指令的参数是否能在常量池中定位到这个类的符号引⽤，如果没有找到这个符号引用，则说明该类还没有被加载过，则开始进行类的加载、解析和初始化过程。
-
分配内存：在类加载检查通过后，接下来虚拟机将为新⽣对象分配内存。对象所需的内存⼤⼩在类加载完成后便可确定，为对象分配空间的任务等同于把⼀块确定⼤⼩的内存从 Java 堆中划分出来。分配⽅式有 “指针碰撞” 和 “空闲列表” 两种，选择哪种分配⽅式由 Java 堆是否规整决定，⽽ Java 堆是否规整⼜由所采⽤的垃圾收集器是否带有压缩整理功能决定。
-
初始化零值：内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这⼀步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用。
-
设置对象头：初始化零值完成之后，虚拟机要对对象进⾏必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的 GC 分代年龄等信息。 这些信息存放在对象头中。
-
执行 init 方法：上⾯⼯作都完成之后，从虚拟机的视⻆来看，⼀个新的对象已经产⽣了，但从 Java 程序的视⻆来看，对象创建才刚开始， ⽅法还没有执⾏，所有的字段都还为零。所以⼀般来说，执⾏ new 指令之后会接着执⾏ ⽅法，把对象按照程序员的意愿进⾏初始化，这样⼀个真正可⽤的对象才算完全产⽣出来。
1 什么是类加载器
类加载器负责将 Java 类动态地加载到虚拟机中并转换成对应的实例，第一次使用该类时才加载。
2 Java 类加载过程
-
加载：通过类加载器把 class 字节码文件载入到内存中；
-
验证：保证加载进来的字节码文件符合虚拟机规范，不会造成安全错误。
-
准备：为静态变量以及常量分配内存，并赋予初值；
-
解析：将常量池内的符号引用替换为直接引用；
-
初始化：对静态变量或者语句进行初始化；
类加载过程是类生命周期的一部分，在这个过程之前，还有源代码的编译，在这个过程之后，还有垃圾回收等。
3 Java 创建对象的过程
-
类加载检查：判断这个类是否被加载过，如果还没未被加载，则先进行类的加载、检查、准备、解析和初始化过程。
-
分配内存：类加载检查通过后，虚拟机会在堆中为新生对象分配内存；
-
初始化零值：虚拟机将分配到的内存空间初始化为零值，除对象头；
-
设置对象头：将对象的类信息放到对象头中；
-
执行初始化方法：比如通过构造方法将对象按照程序员的意愿进行初始化。
4 双亲委派机制
当某个类加载器需要加载某个.class文件时，它首先把这个任务委托给他的上级类加载器，递归这个操作，如果上级的类加载器没有加载且无法加载，自己才会去加载这个类。
作用：
-
防止重复加载同一个
.class； -
保证核心
.class不能被篡改。
5 沙箱安全机制
沙箱安全机制就是将 Java 代码限制在虚拟机的特定环境内运行，并且严格限制代码对本地资源的访问。
-
双亲委派机制-保证 JVM 不被加载的代码破坏；
-
沙箱安全机制-保证机器资源不被 JVM 里运行的程序破坏。
===========================================================================
标记-清除算法采用从根集合（GC Roots）进行扫描，对存活的对象进行标记，标记完毕后，再扫描整个空间中未被标记的对象，进行回收。
标记-清除算法不需要进行对象的移动，只需对不存活的对象进行处理，在存活对象比较多的情况下极为高效，但由于标记-清除算法直接回收不存活的对象，因此会造成内存碎片。
标记-整理算法采用标记-清除算法一样的方式进行对象的标记，但在清除时不同，在回收不存活的对象占用的空间后，会将所有的存活对象往左端空闲空间移动，并更新对应的指针。标记-整理算法是在标记-清除算法的基础上，又进行了对象的移动，因此成本更高，但是却解决了内存碎片的问题。
为了解决效率问题，“复制”收集算法出现了。它可以将内存分为⼤⼩相同的两块，每次使⽤其中的⼀块。当这⼀块的内存使⽤完后，就将还存活的对象复制到另⼀块去，然后再把使⽤的空间⼀次清理掉。这样就使每次的内存回收都是对内存区间的⼀半进⾏回收，这样做的效率较高。
当前虚拟机的垃圾收集都采⽤分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不同将内存分为⼏块。⼀般将 java 堆分为新⽣代和⽼年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
⽐如在新⽣代中，每次收集都会有⼤量对象死去，所以可以选择复制算法，只需要付出少量对象的复制成本就可以完成每次垃圾收集。⽽⽼年代的对象存活⼏率是⽐较⾼的，⽽且没有额外的空间对它进⾏分配担保，所以我们必须选择“标记-清除”或“标记-整理”算法进⾏垃圾收集。
延伸面试问题： 堆内存为什么要分为新⽣代和⽼年代？
将堆内存分为新生代和老年代，可以针对两个分区的不同特点使用不同的垃圾收集算法，从而提高垃圾回收的效率。
==========================================================================
垃圾收集算法是内存回收的方法论，垃圾收集器则是内存回收的具体实现。
虽然我们对各个收集器进⾏⽐较，但并⾮要挑选出⼀个最好的收集器。因为知道现在为⽌还没有最好的垃圾收集器出现，更加没有万能的垃圾收集器，我们能做的就是根据具体应⽤场景选择适合⾃⼰的垃圾收集器。
Serial（串⾏）收集器是最基本、历史最悠久的垃圾收集器了。⼤家看名字就知道这个收集器是⼀个单线程收集器了。它的 “单线程” 的意义不仅仅意味着它只会使⽤⼀条垃圾收集线程去完成垃圾收集⼯作，更重要的是它在进⾏垃圾收集⼯作的时候必须暂停其他所有的⼯作线程（ “Stop The World” ），直到它收集结束。
新⽣代采⽤复制算法，⽼年代采⽤标记-整理算法。
ParNew 收集器其实就是 Serial 收集器的多线程版本，除了使⽤多线程进⾏垃圾收集外，其余⾏为（控制参数、收集算法、回收策略等等）和 Serial 收集器完全⼀样。
新⽣代采⽤复制算法，⽼年代采⽤标记-整理算法。
并⾏和并发概念补充：
-
并发（Concurrent）：指⽤户线程与垃圾收集线程同时执⾏（但不⼀定是并⾏，可能会交替执⾏），⽤户程序在继续运⾏，⽽垃圾收集器运⾏在另⼀个 CPU 上。
-
并行（Parallel） ：指多条垃圾收集线程并⾏⼯作，但此时⽤户线程仍然处于等待状态。
CMS（Concurrent Mark Sweep）收集器是⼀种以获取最短回收停顿时间为⽬标的收集器。它⾮常符合在注重⽤户体验的应⽤上使⽤。
CMS（Concurrent Mark Sweep）收集器是 HotSpot 虚拟机第⼀款真正意义上的并发收集器，它第⼀次实现了让垃圾收集线程与⽤户线程（基本上）同时⼯作。
CMS 等垃圾收集器的关注点更多的是⽤户线程的停顿时间（提⾼⽤户体验），而 Parallel Scavenge 收集器关注点是吞吐量（⾼效率地利⽤CPU）。所谓吞吐量就是 CPU 中⽤于运⾏⽤户代码的时间与 CPU 总消耗时间的⽐值。 这是 JDK1.8 默认收集器。
新⽣代采⽤复制算法，⽼年代采⽤标记-整理算法。
G1 (Garbage-First) 是⼀款⾯向服务器的垃圾收集器，主要针对配备多颗处理器及⼤容量内存的机器。以极⾼概率满⾜ GC 停顿时间要求的同时,还具备⾼吞吐量性能特征。
等。
================================================================================
在JDK1.7以及之前的版本中，堆内存通常被分为三块区域：新生代、老年代、永久代。 新生代又分为：Eden区、From Survivor 区（S0）、To Survivor 区（S1）。默认8:1:1。
而在JDK1.8中情况发生了变化，把存放元数据（永久代）中的永久内存从堆内存中移到了本地内存(native memory)中。
JDK1.8也提供了一个新的设置Matespace（元空间）内存大小的参数，通过这个参数可以设置Matespace内存大小，这样我们可以根据自己项目的实际情况，避免过度浪费本地内存，达到有效利用。
大多数情况下，对象在新生代 Eden区 中分配。当 Eden区没有足够的空间进行分配时，虚拟机发起一次 Minor GC。
大致过程如下：
-
最初一次，当 Eden 区满的时候，执行Minor GC，将消亡的对象清理掉，并将剩余的对象复制到 From 幸存区（此时 To 幸村区是空白的，两个幸存区总有一个是空白的），然后清空 Eden 区。
-
下次 Eden 区满了，再执行一次Minor GC，将消亡的对象清理掉，将存活的对象复制到 To 幸存区中，然后清空 Eden 区。同时，将From 幸存区中消亡的对象清理掉，将其中可以晋级的对象晋级到老年代，将存活的对象也复制到 To 幸存区，然后清空 From 幸存区，然后 To 幸存区和 From 幸存区的互换；
-
当两个存活区切换了几次（HotSpot虚拟机默认15次，用-XX:MaxTenuringThreshold控制）之后，仍然存活的对象将被复制到老年代，即晋级；
-
注意：当发生 Minor GC 的时候，当发现幸存区空间不足，部分对象无法复制到幸存区时，虚拟机通过分配担保机制将这些对象提前转移到老年代。
其中，新生代使用的垃圾收集算法为“复制算法”，老生代使用的垃圾收集算法为“标记-清除”或“标记-整理”算法。
大对象是指，需要大量连续内存空间的 java 对象，最典型的的大对象有：很长的字符串以及数组。
虚拟机提供了一个-XX:PretenureSizeThreshold参数，令大于这个设置值的对象直接在老年代分配。
目的：避免在Eden区和两个Survivor区之间发生大量的内存复制（新生代采用复制算法进行GC）。
虚拟机给每个对象定义了一个对象年龄计数器。
如果对象在Eden区出生，经过第一次Minor GC之后任然存活，并且能被Survivor区容纳，那么对象年龄设置为1。以后，对象在Survivor区中每“熬过”一次Minor GC，年龄就加1，当对象的年龄达到一定程度（默认15岁），就会晋升到老年区中。
通过参数-XX:MaxTenuringThreshold设置。
虚拟机并不是永远要求对象年龄达到设定值才能晋升到老年代。
如果在幸存区空间中低于或等于某个年龄的所有对象大小（内存空间）的总和大于幸存区空间的一半，那么那些年龄大于或者等于该年龄的对象就可以直接进入老年代。
关于动态对象年龄判定的参考文献：传送门
1）谁进行空间担保
空间担保指的是 JVM 在内存分配时，当新生代空间不足，新生代会存活的对象搬到老生代，然后将腾出来的空间用于分配给最新的对象。在这里老年代作为担保人进行空间分配担保。
2）策略内容
在发生Minor GC之前，虚拟机会先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果这个条件成立，那么Minor GC可以确保是安全的。如果不成立，则虚拟机会查看HandlePromotionFailure设置值是否允许担保失败。如果允许，那么会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次Minor GC，尽管这次Minor GC是有风险的；如果小于，或者HandlePromotionFailure设置不允许冒险，那这时要改为进行一次Full GC。
3）为什么需要空间分配担保策略
是因为新生代采用复制收集算法，假如伊甸园区大量对象在Minor GC后仍然存活（最极端情况为内存回收后伊甸园区中所有对象均存活），而幸存区空间是比较小的，这时就需要老年代进行分配担保，把幸存区无法容纳的对象放到老年代。老年代要进行空间分配担保，前提是老年代得有足够空间来容纳这些对象，但一共有多少对象在内存回收后存活下来是不可预知的，因此只好取之前每次垃圾回收后晋升到老年代的对象大小的平均值作为参考。使用这个平均值与老年代剩余空间进行比较，来决定是否进行Full GC来减少晋级的对象数量。
参考文献：传送门
==========================================================================
我们平时代码中使用得最多的引用，对象的类是：StrongReference。就比如上面说的Object obj = new Object()；我们再熟悉不过了，作为最强的引用，只要引用还存在着，垃圾收集器就不会将该引用给回收，即使会出现OOM（内存溢出）。就是说这种引用只要引用还一直指向的对象，垃圾收集器是不会去管它的，所以它被称为强引用。
Object obj = new Object();
obj = null;
不过有两种特殊的情况：
最后
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友
区无法容纳的对象放到老年代。老年代要进行空间分配担保，前提是老年代得有足够空间来容纳这些对象，但一共有多少对象在内存回收后存活下来是不可预知的，因此只好取之前每次垃圾回收后晋升到老年代的对象大小的平均值作为参考。使用这个平均值与老年代剩余空间进行比较，来决定是否进行Full GC来减少晋级的对象数量。
参考文献：传送门
==========================================================================
我们平时代码中使用得最多的引用，对象的类是：StrongReference。就比如上面说的Object obj = new Object()；我们再熟悉不过了，作为最强的引用，只要引用还存在着，垃圾收集器就不会将该引用给回收，即使会出现OOM（内存溢出）。就是说这种引用只要引用还一直指向的对象，垃圾收集器是不会去管它的，所以它被称为强引用。
Object obj = new Object();
obj = null;
不过有两种特殊的情况：
最后
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友
[外链图片转存中…(img-7JOEVUjL-1714390063737)]
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
