1. JVM brief analysis:
As a Java user, it is also necessary to master the architecture of the JVM.
Speaking of Java, we first think of the Java programming language, but in fact, Java is a technology, which consists of four aspects: Java programming language, Java class file format, Java virtual machine and Java application programming interface (Java API) . Their relationship is shown in the figure below:
The Java platform is built by the Java virtual machine and the Java application program interface, and the Java language is the channel to enter this platform. Programs written and compiled in the Java language can run on this platform. The structure of this platform is shown in the following diagram: The runtime environment represents the Java platform, developers write Java code (.java files), which are then compiled into bytecodes (.class files), which are then loaded into Memory, once the bytecode enters the virtual machine, it is interpreted and executed by the interpreter, or is selectively converted into machine code execution by the just-in-time code generator.
The JVM has a clear task in its life cycle, that is, to run a Java program, so when a Java program starts, an instance of the JVM is generated; when the program ends, the instance also disappears. In the structure of the Java platform, it can be seen that the Java Virtual Machine (JVM) is at the core and is the key that the program has nothing to do with the underlying operating system and hardware. Below it is the porting interface, which consists of two parts: the adapter and the Java operating system, of which the platform-dependent part is called the adapter; the JVM is implemented on a specific platform and operating system through the porting interface; the top of the JVM is Java The basic class library and extension class library and their API, the application (application) and applet (Java applet) written by using the Java API can run on any Java platform without considering the underlying platform, because there is a Java virtual machine ( JVM) realizes the separation of the program and the operating system, thus realizing the platform independence of Java.
Below we start from the basic concept and operation process of JVM to conduct in-depth research on it.
2. JVM basic concepts
(1) Basic concepts:
The JVM is a hypothetical computer that can run Java code, including a bytecode instruction set, a set of registers, a stack, a garbage collection, a heap, and a storage method domain. The JVM runs on top of the operating system and has no direct interaction with the hardware.
(2) Operation process:
We all know that Java source files, through the compiler, can produce the corresponding .Class files, that is, bytecode files, and the bytecode files are compiled into machine code on a specific machine through the interpreter in the Java virtual machine.
That is, as follows:
① Java source file --> compiler --> bytecode file
② Bytecode file—>JVM—>Machine code
The interpreter of each platform is different, but the virtual machine implemented is the same, which is why Java can cross-platform. When a program starts to run, the virtual machine starts to be instantiated. When a program starts, there will be multiple virtual machine instances. When the program exits or closes, the virtual machine instance dies, and data cannot be shared among multiple virtual machine instances.
(3) Three JVMs:
① Sun's HotSpot;
② JRockit of BEA;
③ IBM's J9 JVM;
In JDK1.7 and before, we used Sun's HotSpot, but since both Sun and BEA were acquired by oracle, jdk1.8 will use the essence of two JVMs, Sun's HotSpot and BEA's JRockit. JVM of jdk1.8.
3. JVM Architecture
 |
 |
(1) Class Loader class loader
It is responsible for loading the .class file. The class file has a specific file mark at the beginning of the file, and the ClassLoader is responsible for loading the class file. As for whether it can be run, it is determined by the Execution Engine.
① Locate and import binary class files
② Verify the correctness of the imported class
③ Allocate initialization memory for the class
④ Help resolve symbolic references.
(2) Native Interface本地接口:
本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序，Java诞生的时候C/C++横行的时候，要想立足，必须有调用C/C++程序，于是就在内存中专门开辟了一块区域处理标记为native的代码，它的具体作法是Native Method Stack中登记native方法，在Execution Engine执行时加载native libraies。
目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机，或者Java系统管理生产设备，在企业级应用中已经比较少见。
因为现在的异构领域间的通信很发达，比如可以使用Socket通信，也可以使用Web Service等。
(3) Execution Engine 执行引擎：执行包在装载类的方法中的指令，也就是方法。
(4) Runtime data area 运行数据区:
虚拟机内存或者Jvm内存，冲整个计算机内存中开辟一块内存存储Jvm需要用到的对象，变量等，运行区数据有分很多小区，分别为：方法区，虚拟机栈，本地方法栈，堆，程序计数器。
4.JVM数据运行区详解（栈管运行，堆管存储）：
说明：JVM调优主要就是优化 Heap堆 和 Method Area 方法区。
(1) Native Method Stack本地方法栈
它的具体做法是Native Method Stack中登记native方法，在Execution Engine执行时加载native libraies。
(2) PC Register程序计数器
每个线程都有一个程序计算器，就是一个指针，指向方法区中的方法字节码（下一个将要执行的指令代码），由执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不记。
(3) Method Area方法区
方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法如构造函数，接口代码也在此定义。简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间。
静态变量+常量+类信息+运行时常量池存在方法区中，实例变量存在堆内存中。
(4) Stack 栈
① 栈是什么
栈也叫栈内存，主管Java程序的运行，是在线程创建时创建，它的生命期是跟随线程的生命期，线程结束栈内存也就释放，对于栈来说不存在垃圾回收问题，只要线程一结束该栈就Over，生命周期和线程一致，是线程私有的。
基本类型的变量和对象的引用变量都是在函数的栈内存中分配。
② 栈存储什么？
栈帧中主要保存3类数据：
本地变量（Local Variables）：输入参数和输出参数以及方法内的变量；
栈操作（Operand Stack）：记录出栈、入栈的操作；
栈帧数据（Frame Data）：包括类文件、方法等等。
③ 栈运行原理
栈中的数据都是以栈帧（Stack Frame）的格式存在，栈帧是一个内存区块，是一个数据集，是一个有关方法和运行期数据的数据集，当一个方法A被调用时就产生了一个栈帧F1，并被压入到栈中，A方法又调用了B方法，于是产生栈帧F2也被压入栈，B方法又调用了C方法，于是产生栈帧F3也被压入栈…… 依次执行完毕后，先弹出后进......F3栈帧，再弹出F2栈帧，再弹出F1栈帧。
遵循“先进后出”/“后进先出”原则。
(5) Heap 堆
堆这块区域是JVM中最大的，应用的对象和数据都是存在这个区域，这块区域也是线程共享的，也是 gc 主要的回收区，一个 JVM 实例只存在一个堆类存，堆内存的大小是可以调节的。类加载器读取了类文件后，需要把类、方法、常变量放到堆内存中，以方便执行器执行，堆内存分为三部分：
① 新生区
新生区是类的诞生、成长、消亡的区域，一个类在这里产生，应用，最后被垃圾回收器收集，结束生命。新生区又分为两部分：伊甸区（Eden space）和幸存者区（Survivor pace），所有的类都是在伊甸区被new出来的。幸存区有两个：0区（Survivor 0 space）和1区（Survivor 1 space）。当伊甸园的空间用完时，程序又需要创建对象，JVM的垃圾回收器将对伊甸园进行垃圾回收（Minor GC）,将伊甸园中的剩余对象移动到幸存0区。若幸存0区也满了，再对该区进行垃圾回收，然后移动到1区。那如果1去也满了呢？再移动到养老区。若养老区也满了，那么这个时候将产生Major GC（FullGCC），进行养老区的内存清理。若养老区执行Full GC 之后发现依然无法进行对象的保存，就会产生OOM异常“OutOfMemoryError”。
如果出现java.lang.OutOfMemoryError: Java heap space异常，说明Java虚拟机的堆内存不够。原因有二：
a.Java虚拟机的堆内存设置不够，可以通过参数-Xms、-Xmx来调整。
b.代码中创建了大量大对象，并且长时间不能被垃圾收集器收集（存在被引用）。
②养老区
养老区用于保存从新生区筛选出来的 JAVA 对象，一般池对象都在这个区域活跃。
③永久区
永久存储区是一个常驻内存区域，用于存放JDK自身所携带的 Class,Interface 的元数据，也就是说它存储的是运行环境必须的类信息，被装载进此区域的数据是不会被垃圾回收器回收掉的，关闭 JVM 才会释放此区域所占用的内存。
如果出现java.lang.OutOfMemoryError: PermGen space，说明是Java虚拟机对永久代Perm内存设置不够。原因有二：
a. 程序启动需要加载大量的第三方jar包。例如：在一个Tomcat下部署了太多的应用。
b. 大量动态反射生成的类不断被加载，最终导致Perm区被占满。
说明：
Jdk1.6及之前：常量池分配在永久代 。
Jdk1.7：有，但已经逐步“去永久代” 。
Jdk1.8及之后：无(java.lang.OutOfMemoryError: PermGen space,这种错误将不会出现在JDK1.8中)。
 |
 |
说明：方法区和堆内存的异议：
实际而言，方法区和堆一样，是各个线程共享的内存区域，它用于存储虚拟机加载的：类信息+普通常量+静态常量+编译器编译后的代码等等，虽然JVM规范将方法区描述为堆的一个逻辑部分，但它却还有一个别名叫做Non-Heap（非堆），目的就是要和堆分开。
对于HotSpot虚拟机，很多开发者习惯将方法区称之为“永久代（Parmanent Gen）”,但严格本质上说两者不同，或者说使用永久代来实现方法区而已，永久代是方法区的一个实现，jdk1.7的版本中，已经将原本放在永久代的字符串常量池移走。
常量池（Constant Pool）是方法区的一部分，Class文件除了有类的版本、字段、方法、接口等描述信息外，还有一项信息就是常量池，这部分内容将在类加载后进入方法区的运行时常量池中存放。
5.堆内存调优简介
代码测试：
- <span style="font-family:'Microsoft YaHei';font-size:14px;">public class JVMTest {
- public static void main(String[] args){
- long maxMemory = Runtime.getRuntime().maxMemory();//返回Java虚拟机试图使用的最大内存量。
- Long totalMemory = Runtime. getRuntime().totalMemory();//返回Java虚拟机中的内存总量。
- System.out.println("MAX_MEMORY ="+maxMemory +"(字节)、"+(maxMemory/(double)1024/1024) + "MB");
- System.out.println("TOTAL_ MEMORY = "+totalMemory +"(字节)"+(totalMemory/(double)1024/1024) + "MB");
- }
- }</span>
说明：在Run as ->Run Configurations中输入"-XX:+PrintGCDetails"可以查看堆内存运行原理图：
(1) 在jdk1.7中：
(2) 在jdk1.8中:
6.通过参数设置自动触发垃圾回收：
public class JVMTest {
public static void main(String[] args){
long maxMemory = Runtime.getRuntime().maxMemory();//返回Java虚拟机试图使用的最大内存量。
Long totalMemory = Runtime. getRuntime().totalMemory();//返回Java虚拟机中的内存总量。
System.out.println("MAX_MEMORY ="+maxMemory +"(字节)、"+(maxMemory/(double)1024/1024) + "MB");
System.out.println("TOTAL_ MEMORY = "+totalMemory +"(字节)"+(totalMemory/(double)1024/1024) + "MB");
String str = "www.baidu.com";
while(true){
}
}
}
在Run as ->Run Configurations中输入设置“-Xmx8m –Xms8m –xx:+PrintGCDetails”可以参看垃圾回收机制原理:
1.GC算法
是什么
：
频繁收集Young区；
较少收集Old区;
基本不动Perm区。
JVM在进行GC时，并非每次都对上面三个内存区域一起回收的，大部分时候回收的都是指新生代，因此GC按照回收的区域又分了两种类型，一种是普通GC（minor GC），一种是全局GC（major GC or Full GC）。
普通GC（minor GC）：只针对新生代区域的GC。
全局GC（major GC or Full GC）：针对年老代的GC。
3.
GC三大算法
(1) 复制算法：MinorGC（普通GC）
①
年轻代中使用的是Minor GC，这种GC算法采用的是复制算法（Copying）
②
原理：
Minor GC会把Eden中的所有活的对象都移到Survivor区域中，如果Survivor区中放不下，那么剩下的活的对象就被移到Old generation中，也即一旦收集后，Eden是就变成空的了。
当对象在Eden（包括一个Survivor区域，这里假设是from区域）出生后，在经过一次Minor GC后，如果对象还存活，并且能够被另外一块Survivor区域所容纳（上面已经假设为from区域，这里应为to区域，即to区域有足够的内存空间来存储Eden和from区域中存活的对象），则使用复制算法将这些仍然存活的对象复制到另外一块Survivor区域（即to区域）中，然后清理所使用过的Eden以及Survivor区域（即from区域），并且将这些对象的年龄设置为1，以后对象在Survivor区每熬过一次Minor GC，就将对象的年龄+1，当对象的年龄达到某个值时（默认是15岁，通过-XX：MaxTenuringThreshold来定参数），这些对象就会成为老年代。
-XX：MaxTenuringThreshold —设置对象在新生代中存活的次数
③ 解释：
HotSpot JVM把年轻代分为了三部分：1个Eden区和2个Survivor区（分别叫from和to），默认比例为8:1:1，一般情况下，新创建的对象都会被分配到Eden区（一些大对象特殊处理），这些对象经过第一次Minor GC后，如果仍然存活，将会被移到Survivor区，对象在Survivor区中每熬过一次Minor GC，年龄就会增加1岁，当它的年龄增加到一定程度时，就会被移动到年老代中，因为年轻代中的对象基本都是朝生夕死的（80%以上），所以在年轻代的垃圾回收算法使用的是复制算法，复制算法的基本思想就是将内存分为两块，每次只用其中一块，当一块内存用完，就将还活着的对象复制到另外一块上面，复制算法不会产生内存碎片。
在GC开始的时候，对象只会存在于Eden区和名为“From”的Survivor区，Survivor区“To”是空的，紧接着进行GC，Eden区中所在存活的对象都会被复制到“To”，而在“From”区中，仍存活的对象会根据他们的年龄值来决定去向，年龄达到一定值（年龄阈值，可以通过-XX：MaxTenuringThreshold来设置）的对象会被移动到年老代中，没有达到阈值的对象会被复制到“To”区域，经过这次GC后，Eden区和From区已经被清空，这个时候，"From"和“To”会交换他们的角色，也就是新的“To”区域，经过这次"From"，新的“From”就是上次GC前的“To”，不管怎样，都会保证名为To的Survivor区域是空的，Minor GC会一直重复这样的过程，知道“To”区被填满，“To”区被填满之后，会将所有对象移动到年老代中。
因为Eden区对象一般存活率较低，一般的，使用两块10%的内存作为空闲和活动区间，而另外80%的内存，则是用来给新建对象分配内存的，一旦发生GC，将10%的活动区间与另外80%中存活的对象转移到10%的内存区间，接下来，将之前90%的内存全部释放，以此类推。
④ 劣势
复制算法弥补了标记/清楚算法中，内存布局混乱的缺点，不过与此同时，它的缺点也是相当明显的。
a.它浪费了一半的内容，这太要命了。
b.如果对象的存活率很高，我们可以极端一点，假设是100%存活，那么我们需要将所有对象都复制一遍，并将所有引用地址重复一遍，复制这一工作所花费的时间，在对象存活率达到一定程度时，将会变的不可忽视，所以从以上描述不难看出，复制算法要想使用，最起码对象的存活率要非常低才行，而且最重要的是，我们必须要克服50%内存的浪费。
(2) 标记清除算法/标记整理算法：FullGC又叫MajorGC（全局GC）
①老年代一般由标记清除或者标记清楚与标记整理的混合实现。
②标记清除算法(Mark-Sweep)
a.
标记清除
算法原理
b.
标记清除
算法
劣势
一个是效率问题，标记和清除过程的效率都不高；另外一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致，当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
③
标记整理算法(Mark-Compact)
a.
标记整理
算法原理
标记整理
算法
，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
b.
标记整理
算法
劣势
标记整理算法唯一的缺点就是效率不高，不仅要标记所有的存活对象，还要整理所有存活对象引用的地址，用效率上来说，标记整理算法低于复制算法。
(3) 小总结：
①
内存效率：复制算法>标记清除算法>标记整理算法（此处的效率只是简单的对比时间复杂度，实际情况不一定如此）。
②
内存整齐度：复制算法=标记整理算法>标记清楚算法
③
内存利用率：标记整理算法=标记清除算法>复制算法
可以看出，效率上来说，复制算法是当之无愧的老大，但是却浪费了太多内存，而为了尽量兼顾上面所提到的三个指标，标记/整理算法相对来说更平滑一些，但效率上依旧不尽如人意，它比复制算法多了一个标记的阶段，又比标记/清除多了一个整理内存的过程。
难道就没有一种最优算法吗？
答案是无，没有最好的算法，只有最合适的算法======>分代收集算法(
Generational Collection)。
年轻代（Young Gen）
年轻代特点是区域相对老年代较小，对象存活率低。
这种情况复制算法的回收整理，速度是最快的，复制算法的效率只和当前存活对象大小有关，因而很适用于年轻代的回收，而复制算法内存利用率不高的问题，通过hotspot中的两个survivor的设计得到缓解。
老年代（Tenure Gen）
老年代的特点是区域较大，对象存活率高。
这种情况，存在大量存活率高的对象，复制算法明显变得不合适，一般是由标记清除或者是标记清除与标记整理的混合实现。
Mark阶段的开销与存活对象的数量成正比，这点上说来，对于老年代，标记清除或者标记整理有一些不符，但可以通过多核/线程利用，对并发、并行的形式提标记效率。
Sweep阶段的开销与所管理区域的大小形正相关，但Sweep“就地处决”的特点，回收的过程没有对象的移动，使其相对其它有对象移动步骤的回收算法，仍然是效率最好的，但是需要解决内存碎片问题。
Compact阶段的开销与存活对象的数据成正比，如上一条所描述，对于大量对象的移动是很大开销的，作为老年代的第一选择并不合适。
基于上面的考虑，老年代一般由标记清除或者标记清除与标记整理的混合实现。以hotspot中的CMS回收器为例，CMS是基于Mark-Sweep实现的，对于对象的回收效率很高，而对于碎片问题，CMS采用基于Mark-Compact算法的Serial Old回收器做为补偿措施：当内存回收不佳（碎片导致Concurrent Mode Failure时），将采用Serial Old执行Full GC以达到对老年代内存的整理。
永久代(Permanent Space)：存储class类，常量，方法描述：回收废弃常量和无用类。
分代收集法：也就是Jvm的垃圾回收所使用的算法，这种算法，既提高了内存空间的使用，而且根据各代的特点，针对处理，减少了cpu的使用率，提高了性能。
3.垃圾回收器（GC）算法的前世今生
(1) Mark-Sweep算法：
Mark-Sweep算法，也称为：标记-清除法，这是最基本的垃圾回收器算法，过程如下：
① Mark-Sweep分为：
标记
阶段和清除阶段
② 标记要回收的对象，清除回收被标记所占的空间
PS：一个是效率问题，标记和清除过程的效率都不高；另外一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致，当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
(2) Copying算法(复制算法)：
上面说了Mark-Sweep算法，有很大的问题，所以，算法不停的改进，产生了Copying算法，具体情况如下：
① 将内存分为大小相等的两块，每次只使用一块
② 将活着的对象复制到另一块上，使用的清除掉
PS：不容易产生内存碎片，但是内存会缩减到以前的一半，如果存活对象多，效率会很低，所以可以于新区的时候。
(3) Mark-Compact算法(标记整理算法)：
为了解决，空间浪费的问题，算法继续改进，Mark-Compact算法问世，具体情况如下：
① 标记阶段和Mark-Sweep一样
② 完成标记后，不直接清除回收对象，将对象移向一段
③ 清理边界内存
ps：标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
(4) Generational Collection算法
分代收集算法，听名字就知道，因为我们根据存活的生命周期分为了：新生代，老年代和永久代，
具体情况如下：
① 根据存活的生命周期将内存分为若干个区：新生代和老年代和永久代
② 新生代：每次都回收大量对象——>Copying复制法
③ 老年代：每次都回收少量对象——>Mark-Compact法
④ 永久代：存储class类，常量，方法描述：回收废弃常量和无用类
分代收集法：也就是Jvm的垃圾回收所使用的算法，这种算法，既提高了内存空间的使用，而且根据各代的特点，针对处理，减少了cpu的使用率，提高了性能。