联合字节码指令了解Java虚拟机栈和栈帧
栈帧：每个栈帧对应一个被调用的办法，能够了解为一个办法的运行空间
每个栈帧中包含局部变量表（Local Variables），操作数栈(Operand Stack) 执行运行时常量池的援用(A reference to the run-time constant pool），办法返回地址(Return Address）和附加信息
局部变量表：办法中定义的局部变量以及办法的参数寄存在这张表中
局部变量表中的变量不可间接应用，如须要应用的话，必须通过相干指令将其加载至操作数栈中作为操作数应用
操作数栈：以压栈和出栈的形式存储操作数
动静链接：每个栈帧都包好一个指向运行时常量池中该栈帧所属的办法援用，持有这个援用是为了反对办法调用过程中的动静链接（Dynamic Linking）
办法返回地址：当一个办法开始执行后，只有两种形式退出，一种是遇到办法返回的字节码指令，一种是遇见异样，并且这个异样没有在办法体内失去解决。
1 class Person{
private String name="Jack";
private int age;
private final double salary=100;
private static String address;
private final static String hobby="Programming";
public void say(){
System.out.println("person say...");
}
public static int calc(int op1,int op2){
op1=3; int result=op1+op2; return result;
}
public static void order(){ }
public static void main(String[] args){
calc(1,2); order();
}
}class Person {
…
public static int calc(int, int);
Code:
0: iconst\_3 //将int类型常量3压入[操作数栈]
1: istore\_0 //将int类型值存入[局部变量0]
2: iload\_0 //从[局部变量0]中装载int类型值入栈
3: iload\_1 //从[局部变量1]中装载int类型值入栈
4: iadd //将栈顶元素弹出栈，执行int类型的加法，后果入栈
5: istore\_2 //将栈顶int类型值保留到[局部变量2]中
6: iload\_2 //从[局部变量2]中装载int类型值入栈
7: ireturn //从办法中返回int类型的数据
…
}
栈指向堆
如果在栈帧中有一个变量，类型为援用类型，比方Object object=new Object()，这个时候就是典型的栈中元素指向堆中的对象。
办法区指向堆
办法区会寄存动态变量，常量等数据，如果上面的这种状况，就是典型的办法区中元素执行堆中的对象
private static Object obj=new Object();
堆指向办法区
办法区会蕴含类的信息，堆中会有对象，那怎么晓得对象是哪个类创立的呢？
思考：一个对象怎么晓得它是由哪个类创立进去的呢？ 怎么记录呢？ 这就须要理解一个Java对象的具体信息了
Java对象内存布局
一个对象在内存中包含3个局部： 对象头，实例数据和对齐填充
内存模型：
一块是非堆区，一块是堆区。
堆辨别为两大块：一个是old区，一个是Young区，
Young辨别为两个大块，一个是Survivor区(s0+s1），一块是Eden区，Eden：s0:s1=8:1:1
s0和s1一样大,也能够叫From和to
依据之前的对于Heap的介绍能够晓得，个别对象和数组的创立会在堆中分配内存空间，要害是堆中有那么多区域，那一个对象的创立到底在哪个区域呢？
对象创立所在的区域
个别状况下，新创建的对象都会调配到Eden区，一些非凡的大的对象会间接调配到old区
比方 有对象A,B,C等创立Eden区，然而Eden区的内存空间必定无限，比方有100M，如果曾经应用了100M 或者达到一个设定的临界值，这时候就须要对Eden内存空间进行清理，即垃圾收集，这样的GC咱们称之为Minor GC ，Minor GC指得是Young区的GC
通过GC之后，有些对象就会被清理掉，有些对象可能还在存活着，对于存活的对象须要将其复制到Survivor区，而后再清空Eden区中的这些对象
Survivor区详解
survivor辨别为so和s1 ，也能够叫From to 在同一个工夫点上，so和s1只能有一个区有数据，另一个是空的
接着下面的GC来说，比方一开始只有Eden区和From中有对象，To中是空的。此时进行一次GC操作，From区中对象的年龄就会+1，咱们晓得Eden区中所有存活的对象会被复制到To区，
From区中还能存活的对象会有两个去处。若对象年龄达到之前设置好的年龄阈值，此时对象会被挪动到Old区，如果Eden区和From区没有达到阈值的对象会被复制到To区。
此时Eden区和From区曾经被清空(被GC的对象必定没了，没有被GC的对象都有了各自的去处)。这时候From和To替换角色，之前的From变成了To，之前的To变成了From。
也就是说无论如何都要保障名为To的Survivor区域是空的。Minor GC会始终反复这样的过程，晓得To区被填满，而后会将所有对象复制到老年代中。
Old区详解
从下面的剖析能够看出，个别Old区都是年龄比拟大的对象，或者绝对超过了某个阈值的对象。在Old区也会有GC的操作，Old区的GC咱们称作为Major GC
对象的一辈子了解
我是一个一般的Java对象,我出世在Eden区,在Eden区我还看到和我长的很像的小兄弟,咱们在Eden区中玩了挺长时间。有一天Eden区中的人切实是太多了,我就被迫去了Survivor区的“From”区,自从去了Survivor区,我就开始漂了,有时候在
Survivor的“From”区,有时候在Survivor的“To”区,居无定所。直到我18岁的时候,爸爸说我成人了,该去社会上闯闯了。于是我就去了年轻代那边,年轻代里,人很多,并且年龄都挺大的,我在这里也意识了很多人。在年轻代里,我生存了20年(每次
GC加一岁),而后被回收。
常见问题
1.如何了解Minor GC ，Major GC，Full GC
Minor GC：新生代
Major GC：老年代
Full GC ：新生代+老年代
2.为什么须要Survivor区？只有Eden不行吗？
如果没有Survivor,Eden区每进行一次Minor GC,并且没有年龄限度的话，存活的对象就会被送到老年代。这样一来，老年代很快被填满,触发Major GC(因为Major GC个别随同着Minor GC,也能够看做触发了Full GC)。
老年代的内存空间远大于新生代,进行一次Full GC耗费的工夫比Minor GC长得多。执行工夫长有什么害处?频发的Full GC耗费的工夫很长,会影响大型程序的执行和响应速度。
可能你会说，那就对老年代的空间进行减少或者较少咯。如果减少老年代空间，更多存活对象能力填满老年代。尽管升高Full GC频率，然而随着老年代空间加大,一旦产生Full
GC,执行所须要的工夫更长。如果缩小老年代空间，尽管Full GC所需工夫缩小，然而老年代很快被存活对象填满,Full GC频率减少。
所以Survivor的存在意义,就是缩小被送到老年代的对象,进而缩小Full GC的产生,Survivor的预筛选保障,只有经验16次Minor GC还能在新生代中存活的对象,才会被送到老年代。
3 为什么须要两个Survivor区？
最大的益处就是解决了碎片化。也就是说为什么一个Survivor区不行?第一局部中,咱们晓得了必须设置Survivor区。假如当初只有一个Survivor区,咱们来模仿一下流程:
刚刚新建的对象在Eden中,一旦Eden满了,触发一次Minor GC,Eden中的存活对象就会被挪动到Survivor区。这样持续循环上来,下一次Eden满了的时候,问题来了,此时进行Minor GC,Eden和Survivor各有一些存活对象,如果此时把Eden区的
存活对象硬放到Survivor区,很显著这两局部对象所占有的内存是不间断的,也就导致了内存碎片化。永远有一个Survivor space是空的,另一个非空的Survivor space无碎片。
4 新生代中Eden：s1:s0 为什么是8:1:1?
新生代中的可用内存：复制算法用来担保的内容为9：1
可用内存中Eden：s1区为8:1
即新生代中Eden：s1：s2=8:1：1
体验与验证
1） 堆内存溢出
@RestController
public class HeapController {
List<Person> list=new ArrayList<Person>();
@GetMapping("/heap")
public String heap() throws Exception{
while(true){
list.add(new Person());
Thread.sleep(1);
}
}
}记得设置参数比方-Xmx20M -Xms20M
运行后果：
Exception in thread “http-nio-8080-exec-2” java.lang.OutOfMemoryError: GC overhead limit
exceeded
2）办法区内存溢出
比方向办法区中增加class的信息
<dependency>
<groupId>asm</groupId>
<artifactId>asm</artifactId>
<version>3.3.1</version>
</dependency>
public class MyMetaspace extends ClassLoader {
public static List<Class<?>> createClasses() {
List<Class<?>> classes = new ArrayList<Class<?>>();
for (int i = 0; i < 10000000; ++i) {
ClassWriter cw = new ClassWriter(0);
cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
MethodVisitor mw = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
mw.visitVarInsn(Opcodes.ALOAD, 0);
mw.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
mw.visitInsn(Opcodes.RETURN);
mw.visitMaxs(1, 1);
mw.visitEnd();
Metaspace test = new Metaspace();
byte[] code = cw.toByteArray();
Class<?> exampleClass = test.defineClass("Class" + i, code, 0, code.length);
classes.add(exampleClass);
}
return classes;
}
}@RestController public class NonHeapController {
List<Class<?>> list=new ArrayList<Class<?>>();
@GetMapping("/nonheap") public String nonheap() throws Exception{
while(true){
list.addAll(MyMetaspace.createClasses());
Thread.sleep(5); } } }设置Metaspace的大小，比方-XX:MetaspaceSize=50M -XX:MaxMetaspaceSize=50M
运行后果：
java.lang.OutOfMemoryError: Metaspace
at java.lang.ClassLoader.defineClass1(Native Method) ~[na:1.8.0\_191]
at java.lang.ClassLoader.defineClass(ClassLoader.java:763) ~[na:1.8.0\_191]
虚拟机栈
public class StackDemo {
public static long count=0;
public static void method(long i){
System.out.println(count++);
method(i); }
public static void main(String[] args) { method(1); } }
了解和阐明：
Stack Space用来做办法的递归调用时压入Stack Frame(栈帧)。所以当递归调用太深的时候，就有可能耗尽StackSpace，爆出StackOverflow的谬误。
-Xss128k：设置每个线程的堆栈大小。JDK 5当前每个线程堆栈大小为1M，以前每个线程堆栈大小为256K。依据利用的线程所需内存大小进行调整。在雷同物理内存下，减小这个值能生成更多的线程。然而操作系统对一个过程内的线程数还是有
限度的，不能有限生成，经验值在3000~5000左右。线程栈的大小是个双刃剑，如果设置过小，可能会呈现栈溢出，特地是在该线程内有递归、大的循环时呈现溢出的可能性更
大，如果该值设置过大，就有影响到创立栈的数量，如果是多线程的利用，就会呈现内存溢出的谬误。
关注公众号:java宝典
发表回复