E.JVM

1、JVM定义

Java虚拟机包括程序计数器(线程私有)，虚拟机栈(线程私有)，本地方法栈（线程私有），Java堆（线程共享），方法区（线程共享）。 JVM屏蔽了与具体操作系统平台相关的信息，在执行字节码时，实际上最终是把字节码解释成具体平台上的机器指令执行。

image.png

2、JVM运行时数据区

大多数 JVM 将内存区域划分为 程序计数器 , 虚拟机栈 , 本地方法栈，方法区 ,堆 。其中方法区和堆 是线程共享的 ，程序计数器，虚拟机栈，本地方法栈 是非线程共享的。为什么分为 线程共享和非线程共享的呢?

概括地说来，JVM初始运行的时候都会分配好 Method Area（方法区） 和Heap（堆） ，而JVM 每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） , VM Stack（虚拟机栈）和Native Method Stack （本地方法栈）， 当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说只发生在Heap上）的原因。

程序计数器

如果方法不是native的，pc寄存器包含当前正在被执行的jvm指令地址，如果方法是native的，pc寄存器的值是未定义的。
程序计数器的主要作用是记录线程运行时的状态，方便线程被唤醒时能从上一次被挂起时的状态继续执行，需要注意的是，程序计数器是唯一一个在 Java 虚拟机规范中没有规定任何 OOM 情况的区域

JVM栈

在函数中定义的一些基本类型的变量和对象的引用变量、方法局部变量 、方法的返回地址都是在函数的栈内存中分配，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

栈具有数据结构中栈的特点，后进先出，所有存放在它里面的数据都是生命周期很明确（当然要求它不能存放太久，占有的空间确定而且占用空间小），能够快速反应的！所有在Java中它存放的是8个基本数据类型[整型 byte short int long\浮点型 float double\逻辑型 boolean\字符型 char]和引用变量的，用完就马上销毁

优点：存取速度比堆要快，仅次于寄存器。

缺点：存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

堆

所有对象都在这里分配内存，是垃圾收集的主要区域（"GC 堆"）。
堆不需要连续内存，并且可以动态增加其内存，增加失败会抛出 OutOfMemoryError 异常。

它是JVM用来存储对象实例以及数组值的区域，Java中所有通过new创建的对象和定义的数组的内存都在此分配，还包括类的成员变量，Heap中的对象的内存需要等待GC进行回收。

（1） 堆是JVM中所有线程共享的，因此在其上进行对象内存的分配均需要进行加锁，这也导致了new对象的开销是比较大的

（2） Sun Hotspot JVM为了提升对象内存分配的效率，对于所创建的线程都会分配一块独立的空间TLAB（Thread Local Allocation Buffer），其大小由JVM根据运行的情况计算而得，在TLAB上分配对象时不需要加锁，因此JVM在给线程的对象分配内存时会尽量的在TLAB上分配，在这种情况下JVM中分配对象内存的性能和C基本是一样高效的，但如果对象过大的话则仍然是直接使用堆空间分配

（3） TLAB仅作用于新生代的Eden Space，因此在编写Java程序时，通常多个小的对象比大的对象分配起来更加高效。

优点：堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。

缺点是：由于要在运行时动态分配内存，存取速度较慢。

方法区域（静态存储区）

• 用于存放已被加载的类信息、常量、静态变量。
• 和堆一样不需要连续的内存，并且可以动态扩展，动态扩展失败一样会抛出 OutOfMemoryError 异常。
• 对这块区域进行垃圾回收的主要目标是对常量池的回收和对类的卸载，但是一般比较难实现。

String s = "hello";
String t = "hello";
System.out.println(s==t);// true  s和t指向内存常量区的同一个字符串 ;

 class A
{
  private String a = "aa"; // a 为成员变量的引用，在堆区，“aa”为未经 new 的常量，在常量区
  public boolean methodB() {
    String  b = "bb"; // b 为局部变量的引用，在栈区，“bb”为未经 new 的常量，在常量区
    final String c ="cc"; // c 为局部变量的引用，在栈区，“cc”为未经 new 的常量，在常量区
   }
}

本地方法堆栈（Native Method Stacks）

本地方法栈与 Java 虚拟机栈类似，它们之间的区别只不过是本地方法栈为本地方法服务。

本地方法一般是用其它语言（C、C++ 或汇编语言等）编写的，并且被编译为基于本机硬件和操作系统的程序，对待这些方法需要特别处理。

本地内存

线程共享区域，Java 8 中，本地内存，也是我们通常说的堆外内存，包含元空间和直接内存,注意到上图中 在 Java 8 之前有个永久代的概念，实际上指的是 HotSpot 虚拟机上的永久代，它用永久代实现了 JVM 规范定义的方法区功能，主要存储类的信息，常量，静态变量，即时编译器编译后代码等，这部分由于是在堆中实现的，受 GC 的管理，不过由于永久代有 -XX:MaxPermSize 的上限，所以如果动态生成类（将类信息放入永久代）或大量地执行 String.intern （将字段串放入永久代中的常量区），很容易造成 OOM，有人说可以把永久代设置得足够大，但很难确定一个合适的大小，受类数量，常量数量的多少影响很大。所以在 Java 8 中就把方法区的实现移到了本地内存中的元空间中，这样方法区就不受 JVM 的控制了,也就不会进行 GC，也因此提升了性能，也就不存在由于永久代限制大小而导致的 OOM 异常。

2.1对象的创建方法

• 使用new关键字-->调用了构造函数
• 使用class类的newInstance()方法-->调用了构造函数class.forName().newInstance()
• 使用反射的Constructor类的newinstance()方法-->调用了构造函数
  Constructor constructor = Person.class.getConstructor(int.class);
Person person = constructor.newInstance(23);
• 使用clone方法
• 使用反序列化,类需要实现serializable接口

2.2 对象的内存分配

Object obj = new Object();

obj 保存在java栈中的局部变量表里，作为一个引用数据出现。 New Object()会在java堆上分配一块存储Object类型实例的所有数值的结构化内存。

2.3 对象的访问定位

对象访问方式有两种：句柄和直接指针:

句柄：在java堆中会划分出一块内存作为句柄池，reference中存储的对象是句柄地址。而句柄中包含对象实例数据和类型数据各自的具体地址信息。最大的好处是如果对象地址发生变化不需要改变reference的值，只需要改变句柄中实例数据指针。

直接指针访问：reference直接存储对象的地址，最大的好处是速度更快。

小结

• JVM运行时内存 = 共享内存区 + 线程内存区

• 共享内存区=堆+持久带

• 持久带实现了方法区

• 堆=新生代+年老代（新生代占堆空间的1/3;年老代占堆空间的2/3）

  • 堆分为Old Space和Young Space。

  • Old Space主要存放应用程序中生命周期长的存活对象；

  • 新生代=eden+S0+S1，(空间为8:1:1)Eden(伊甸园)主要存放新生的对象；S0和S1是两个大小相同的内存区域，主要存放每次垃圾回收后Eden存活的对象，作为对象从Eden过渡到Old Space的缓冲地带（S是指英文单词Survivor Space）。堆之所以要划分区间，是为了方便对象创建和垃圾回收

• 线程内存区=单个线程内存+单个线程内存+.......

  单个线程内存=PC Regster+JVM栈+本地方法栈

  JVM栈=栈帧+栈帧+.....

  一个栈帧代表一个方法调用。

3、JVM垃圾回收

垃圾收集主要是针对堆和方法区进行。程序计数器、虚拟机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内，线程结束之后就会消失，因此不需要对这三个区域进行垃圾回收。

GC (Garbage Collection)的基本原理：将内存中不再被使用的对象进行回收，GC中用于回收的方法称为收集器，由于GC需要消耗一些资源和时间，Java在对对象的生命周期特征进行分析后，按照新生代、旧生代的方式来对对象进行收集，以尽可能的缩短GC对应用造成的暂停

3.1 判断一个对象是否死亡

引用计数算法

给对象添加一个引用计数器，每当一个地方引用，计数器的值加1；当引用失效时，计数器的值减1；任何技术器为0的对象就是不可能再被使用的对象。

//在上述代码中，a 与 b 引用的对象实例互相持有了对象的引用，
//因此当我们把对 a 对象与 b 对象的引用去除之后
//由于两个对象还存在互相之间的引用，导致两个 Test 对象无法被回收。
public class Test {

    public Object instance = null;

    public static void main(String[] args) {
        Test a = new Test();
        Test b = new Test();
        a.instance = b;
        b.instance = a;
        a = null;
        b = null;
        doSomething();
    }
}

image.png

实现简单，判定效率高，但是很难解决对象之间的相互循环引用的问题。

可达性分析算法

现代虚拟机基本都是采用这种算法来判断对象是否存活，可达性算法的原理是以一系列叫做 GC Root 的对象为起点出发，引出它们指向的下一个节点，再以下个节点为起点，引出此节点指向的下一个结点。。。（这样通过 GC Root 串成的一条线就叫引用链），直到所有的结点都遍历完毕,如果相关对象不在任意一个以 GC Root 为起点的引用链中，则这些对象会被判断为「垃圾」,会被 GC 回收。

image.png

如图示，如果用可达性算法即可解决上述循环引用的问题，因为从GC Root 出发没有到达 a,b,所以 a，b 可回收
a, b 对象可回收，就一定会被回收吗?并不是，对象的 finalize 方法给了对象一次垂死挣扎的机会，当对象不可达（可回收）时，当发生GC时，会先判断对象是否执行了 finalize 方法，如果未执行，则会先执行 finalize 方法，我们可以在此方法里将当前对象与 GC Roots 关联，这样执行 finalize 方法之后，GC 会再次判断对象是否可达，如果不可达，则会被回收，如果可达，则不回收！
注意： finalize 方法只会被执行一次，如果第一次执行 finalize 方法此对象变成了可达确实不会回收，但如果对象再次被 GC，则会忽略 finalize 方法，对象会被回收！这一点切记!

GC用的引用可达性分析算法中，哪些对象可作为GC Roots对象？
​ • Java虚拟机栈中引用的对象
​ • 方法区中的静态成员引用的对象
​ • 方法区中的常量引用对象
​ • 本地方法区中的JNI（Native方法）引用对象。

3.2 引用类型

无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象是否可达，判定对象是否可被回收都与引用有关。
Java 提供了四种强度不同的引用类型。

（1）强引用：广泛存在的，类似"Object obj=new Object()",只要强引用还在，垃圾收集器永远不会回收掉被引用的对象。

（2）软引用：描述一些有用，但非必需的对象，软引用是Java中提供的一种比较适合于缓存场景的应用（只有在内存不够用的情况下才会被GC）
使用 SoftReference 类来创建软引用。

Object obj = new Object();
SoftReference