![mark](https://img.zouchanglin.cn///20200316/mALYmfXLzFOP.png)

在Java语言中，除了原始数据类型的变量，其他所有都是所谓的引用类型，指向各种不同的对象，理解引用对于掌握Java对象生命周期和JVM内部相关机制非常有帮助。本文讲述了强引用、软引用、弱引用、幻象引用的区别以及一些具体使用场景，而且是配合ReferenceQueue使用。



# 强引用

我们平常典型编码0bject obj = new Object()中的obj就是强引用。通过关键字new创建的对象所关联用就是强引用。当IVM内存空间不足，JVM宁愿抛出OutOfMemoryError运行时错误(OOM)，使程序异常终止，也不会靠随意回收具有强引用的"存活”对象来解决内存不足的问题。对于个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应(强)引用赋值为null，就是可以被垃圾收集的了，具体回收时机还是要看垃圾收集策略。

# 软引用

软引用通过SoftReference类实现。软引 l用的生命周期比强引用短一些。只有当JVM认为内存不足时，才会去试图回收软引用指向的对象：即JVM 会确保在抛出OutOfMemoryError之前，清理软引用指向的对象。软用可以和一个引用队列(ReferenceQueue) 联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。后续，我们可以调用ReferenceQueue的poll()方法来检查是否有它所关心的对象被回收。如果队列为空，将返回一个null，该方法返回队列中前面的一个Reference对象。

应用场景：软引用通常用来实现内存敏感的缓存。如果还有空闲内存，就可以暂时保留缓存，当内存不足时清理掉，这样就保证了使用缓存的同时，不会耗尽内存。

```java
String str = new String("ABC"); //强引用
SoftReference<String> softReference = new SoftReference<>(str); //软引用
```



# 弱引用

弱引用通过WeakReference类实现。弱用的生命周期比软引用短。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。于垃圾回收器是一个优先级很低的线程，因此不一定会很快回收弱引用的对象。弱引用可以和引用队列(ReferenceQueue) 联合使用，如果弱引用所引用的对象被垃圾回收，Java虛拟机就会把这个弱用加入到与之关联的引用队列中。

应用场景：弱应用同样可用于内存敏感的缓存。

在静态内部类中，经常会使用虚引用。例如：一个类发送网络请求，承担callback的静态内部类，则常以虚引用的方式来保存外部类(宿主类)的引用，当外部类需要被JVM回收时，不会因为网络请求没有及时回来，导致外部类不能被回收，引起内存泄漏

```java
String str = new String("ABC"); //强引用
WeakReference<String> weakReference = new WeakReference<>(str); //弱引用
```



# 虚引用

特点：虚引用也叫幻象引用，通过PhantomReference类来实现。无法通过引用访问对象的任何属性或函数。幻象引用仅仅是提供了一种确保对象被finalize以后，做某些事情的机制。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用必须和引用队列(ReferenceQueue) 联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

```java
ReferenceQueue queue = new ReferenceQueue();
PhantomReference pr = new PhantomReference(object, queue);
```

程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取一些程序行动。

应用场景：可用来跟踪对象被垃圾回收器回收的活动，当一个引用关联的对象被垃圾收集器回收之前会收到一系统通知。

```java
String str = new String("ABC"); //强引用
ReferenceQueue<String> referenceQueue = new ReferenceQueue<>(); //引用队列
PhantomReference<String> phantomReference = new PhantomReference<String>(str,referenceQueue); //虚引用
```

# ReferenceQueue

四种引用由强到弱分别是：强引用 > 软引用 > 弱引用 > 虚引用。

![mark](https://img.zouchanglin.cn///20200316/mALYmfXLzFOP.png)

ReferenceQueue无实际存储结构，存储逻辑依赖于内部节点之间的关系来表达。存储关联的且被GC的软引用，弱引用以及虚引用。下面可以看一个示例：

> **NormalObject.java**

```java
package xpu.edu.tim;

public class NormalObject {
    public String name;
    public NormalObject(String name) {
        this.name = name;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Finalizing obj " + name);
    }
}
```

> **NormalObjectWeakReference.java**

```java
package xpu.edu.tim;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

public class NormalObjectWeakReference  extends WeakReference<NormalObject> {
    public String name;

    public NormalObjectWeakReference(NormalObject normalObject, ReferenceQueue<NormalObject> q) {
        super(normalObject, q);
        this.name = normalObject.name;
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("Finalizing NormalObjectWeakReference "+ name);
    }
}
```

> **ReferenceQueueTest.java**

```java
package xpu.edu.tim;

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

public class ReferenceQueueTest {
    private static ReferenceQueue<NormalObject> rq = new ReferenceQueue<>();

    private static void checkQueue(){
        Reference<NormalObject> reference = null;
        while ((reference = (Reference<NormalObject>) rq.poll()) != null){
            if(reference != null){
                System.out.println("In queue: "+ ((NormalObjectWeakReference)reference).name);
                System.out.println("reference object: "+ reference.get());
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ArrayList<WeakReference<NormalObject>> weakReferenceArrayList = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            weakReferenceArrayList.add(new NormalObjectWeakReference(new NormalObject("Weak " + i), rq));
            System.out.println("Created weak:" + weakReferenceArrayList.get(i));
        }
        System.out.println("First time");
        checkQueue();
        System.gc();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("Second time");
        checkQueue();
        System.out.println("Third time");
    }
}
```

![mark](https://img.zouchanglin.cn///20200316/RIKBUcpyQGGK.png)

上面的示例是否有点复杂呢？看看下面这个也行：

```java
package xpu.edu.tim;

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.concurrent.TimeUnit;

public class EasyReferenceQueueDemo {
    public static void main(String[] args) {
        Object object = new Object();
        ReferenceQueue referenceQueue = new ReferenceQueue<>();
        PhantomReference<Object> phantomReference = new PhantomReference<>(object, referenceQueue);
        object = null;
        System.gc();
        try {
            TimeUnit.SECONDS.sleep(1); //给GC足够时间回收
            Reference<Object> reference = referenceQueue.remove(2000L);
            if(reference != null){
                //TODO something
                System.out.println("do something");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

最终打印出do something，remove是一个阻塞方法，可以指定timeout， 或者选择一直阻塞。

Java的四种引用

用过JDK9的同学应该发现了，finalize方法在JDK9中已经被标记为deprecated，今天探讨一下finalize方法。如果没有特别的原因，不要实现finalize方法，也不要指望利用它来进行资源回收。因为你无法保证finalize什么时候执行，执行的是否符合预期。使用不当会影响性能，导致程序死锁、挂起等。



首先要明白的是为什么会出现finalize方法，因为早期一部分程序员是写C++的，仍然保留析构函数释放资源的行为，所以为了让他们平滑的过渡到Java并且适应Java，所以出现了finalize方法，用来对象被回收前的一次自我拯救，完成释放资源的操作。那么Object的finalize()方法的作用是否与C++的析构函数作用相同呢？其实finalize方法与C++的析构函数是有很大不同的，析构函数调用确定，而finalize是不确定的。重写了finalize的对象如果未被引用就会被放置于F-Queue队列，而且由一个优先级极底的线程成来执行finalize方法，而且方法执行随时可能会被终止。

finalize的执行是和垃圾收集关联在一起的，一实现了非空的finalize 方法，就会导致相应对象回收呈现数量级上的变慢，有人专做过benchmark，大概是40~ 50倍的下降。因为，finalize被设计成在对象被垃圾收集前调用，这就意味着实现了finalize方法的对象是个“特殊公民”， JVM要对它进行额外处理。finalize本质上成为了快速回收的阻碍者，可能导致你的对象经过多个垃圾收集周期才能被回收。

下面来看一个示例：

```java
public class Finalization {
    public static Finalization finalization;
    @Override
    protected void finalize(){
        System.out.println("Finalized");
        finalization = this;
    }

    public static void main(String[] args) {
        Finalization f = new Finalization();
        System.out.println("First print: " + f);
        f = null;
        System.gc();
        try {
            // 休息一段时间，让上面的垃圾回收线程执行完成
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("Second print: " + f);
        System.out.println(f.finalization);
    }
}
```

![mark](https://img.zouchanglin.cn///20200315/4JYIlNjnvNyH.png)

可见finalize会拖慢垃圾收集，导致对象堆积，容易导致OOM，而且使用finalize释放资源是不合理的，资源应该是用完立即释放的，或者采用资源池来解决这个问题，而不是依靠被动垃圾回收时触发finalize方法。

请丢弃finalize

![](https://img.zouchanglin.cn///20200312/5dC8XXcmBoUn.png)

目前的垃圾收集器主要有7种，上图是他们的使用关系，连在一起的就可以配合使用。JDK11出现两种新的垃圾收集器，一个是Epsilon垃圾收集器，一个是ZGC垃圾收集器。垃圾收集器中很重要的两个概念：Stop-The-World和Safepoint。首先说说Stop-The-World：JVM由于要执行GC而停止了应用程序的执行，任何一种GC算法中都会发生。多数GC优化通过减少Stop-the -world发生的时间来提高程序性能。安全点 Safepoint：分析过程中对象引用关系不会发生变化的点，产生Safepoint的地方：方法调用、循环跳转、异常跳转等，安全点数量得适中。



# 各种收集器的关系

JVM的两种运行模式，在《HotSpot JVM类型以及编译模式》 一文中说道了，JVM有Server和Client型、Server型启动比较慢，属于做了重量级的优化，Client型启动较Server快。

> 下面来看看三个新生代的收集器：Serial收集器、Serial收集器和Parallel Scavenge收集器

# 1、Serial收集器

Serial收集器（-XX:+UseSerialGC，复制算法）是Java中最基本的收集器，历史悠久，在JDK1.3.1之前是Java虚拟机新生代的唯一选择。单线程收集，进行垃圾收集时，必须暂停所有工作线程。由于Serial收集器采用复制算法，简单高效，Client模式下默认的年轻代收集器就是Serial。

![](https://img.zouchanglin.cn///20200312/LnTVebt88Fib.png)

# 2、ParNew收集器

ParNew收集器（-XX:+UseParNewGC，复制算法），多线程收集， ParNew收集器其实是Serial收集器的多线程版本，它是许多运行在Server模式下的虚拟机中首选的新生代收集器，其余的行为特点和Serial收集器一样。单核执行效率不如Serial（因为存在线程切换的开销），在多核下执行才有优势。

同时ParNew也是一个很重要的垃圾收集器， 因为除了Serial收集器外，目前只有它能与CMS收集器配合工作。

![](https://img.zouchanglin.cn///20200312/cIldVTMEv8cm.png)

> **Serial与ParNew收集器都是比较强调很短的停顿时间。**

# 3、Parallel Scavenge收集器

Parallel Scavenge收集器（-XX:+UseParallelGC，复制算法），多线程收集，比起关注用户线程停顿时间，更关注系统的吞吐量。在多核下执行才有优势，Server模式下默认的年轻代收集器

吞吐量即CPU用于运行用户代码的时间与CPU总消耗时间的比值，吞吐量=运行用户代码时间 /（运行用户代码时间+垃圾收集时间）， 假设虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，吞吐量就是99%。 

> **对于需要与用户交互的程序来说停顿时间越短越好，良好的响应速度能提升用户的体验。**
>
> **对于后台计算等任务，需要最高效率地利用CPU时间，尽快地完成程序的运算任务，这就是高吞吐量**

![](https://img.zouchanglin.cn///20200312/cIldVTMEv8cm.png)

上图与ParNew收集器的一致，因为都是多线程+复制算法收集，只不过关注点不同，ParNew收集器关注停顿时间，而Parallel Scavenge收集器关注吞吐量。下面看看相关参数：

`-XX:MaxGCPauseMillis` 控制最大垃圾收集停顿时间（大于0的毫秒数）。停顿时间缩短是以牺牲吞吐量和新生代空间换取的。（新生代调的小，吞吐量跟着小，垃圾收集时间就短，停顿就小）。

`-XX:GCTimeRatio` 直接设置吞吐量大小，0<x<100 的整数，允许的最大GC时间=1/(1+x)。

`-XX:+UseAdaptiveSizePolicy`  一个开关参数，开启GC自适应调节策略（GC Ergonomics），将内存管理的调优任务（新生代大小-Xmn、Eden与Survivor区的比例-XX:SurvivorRatio、晋升老年代对象年龄-XX:PretenureSizeThreshold 、等细节参数）交给虚拟机完成。

> 下面来看看三个老年代的收集器：Serial Old收集器、Serial收集器和Parallel Scavenge收集器

# 4、Serial Old收集器

Serial Old收集器（-XX:+UseSerialOldGC，标记-整理算法），单线程收集，进行垃圾收集时，必须暂停所有工作线程。简单高效，Client模式下默认的老年代收集器。

![](https://img.zouchanglin.cn///20200312/CkIzw5MKaF77.png)

# 5、Parallel Old收集器

Parallel Old收集器（-XX : +UseParallelOldGC，标记-整理算法）JDK6以后提供的。

Parallel Scavenge收集器其实在Parallel Old收集器没有出现之前一直处于比较尴尬的地位，因为能与之配合的老年代收集器只有Serial Old，Serial Old性能上拖累了Parallel Scavenge，所以即使在需要高吞吐量的情况下，虽然使用了Parallel Scavenge收集器，但是由于只能跟Serial Old收集器配合，结果性能还不如ParNew和CMS的组合收集器，Parallel Old收集器的出现总算是给Parallel Scavenge收集器搭配了一个好基友！

![](https://img.zouchanglin.cn///20200312/GdPddhTBdmwL.png)

> **所以在注重吞吐量及CPU资源敏感的场合，都可以优先考虑Parallel Scavenge+Parallel Old收集器**

# 6、CMS收集器

CMS收集器（-XX: +UseConcMarkSweepGC，标记-清除算法）， 以获取最短回收停顿时间为目标的收集器。优点：并发收集，低停顿。CMS收集器主要由以下6个步骤完成垃圾收集工作：

* 初始标记：stop-the-world，标记GC Roots能直接关联到的对象，虽然暂停了JVM，但是速度非常快
* 并发标记：在初始标记上并发追溯标记，程序不会停顿
* 并发预清理：查找执行并发标记阶段从年轻代晋升到老年代的对象，通过重新扫描减少下一个阶段的标记工作
* **重新标记：暂停虚拟机，扫描CMS堆中的剩余对象，速度较慢一些**
* 并发清理：清理垃圾对象，程序不会停顿
* 并发重置：重置CMS收集器的数据结构

这6个步骤中初始标记和重新标记是需要暂停JVM的，是费时操作

![](https://img.zouchanglin.cn///20200312/DPxBI6qcesti.png)

CMS收集器对CPU资源非常敏感，面向并发设计的程序都会对CPU资源较敏感。CMS默认的回收线程数:(CPU数量+3)/4， 而且CMS收集器是基于标记-清除算法会产生大量空间碎片。

# 7、G1收集器

G1收集器（-XX:+UseG1GC，复制算法 + 标记-整理算法），G1收集器全称是GarBage First。

G1收集器可以在几乎不牺牲吞吐量的前提下完成低停顿的内存回收，这是由于它能够极力避免全区域的垃圾收集，之前的收集器进行收集的范围都是整个新生代或老年代，而G1将整个Java堆（包括新生代、老年代）划分为多个大小固定的独立区域（Region），并且跟踪这些区域里面的垃圾堆积程度，在后台维护一个优先列表，每次根据允许的收集时间，优先回收垃圾最多的区域（这就是Garbage First名称的由来）。区域划分、有优先级的区域回收，保证了G1收集器在有限的时间内可以获得最高的收集效率。

![](https://img.zouchanglin.cn///20200312/Ai7bWBvLJ9Pm.png)

G1收集器的特点：并行和并发、分代收集、空间整合、可预测的停顿。G1将整个Java堆（包括新生代、老年代）划分为多个大小固定的独立区域（Region），物理上可以不是连续的，年轻代和老年代空间大小动态可调整。

# 8、Epsilon垃圾收集器

-XX: +UnlockExperimentalVMOptions、-XX:+UseEpsilonGC，Epsilon垃圾收集器是Java11出现的垃圾收集器， JDK上对这个特性的描述是：开发一个处理内存分配但不实现任何实际内存回收机制的GC，一旦可用堆内存用完，JVM就会退出。

Epsilon垃圾收集器提供完全被动的GC实现，具有有限的分配限制和尽可能低的延迟开销，但代价是内存占用和内存吞吐量。使用场景：

1、使用此GC来做性能测试(因为可以帮助过滤掉GC引起的性能假象) 还是不错的；

2、用来做内存压力测试也还行；

3、 如果是执行非常短的任务，根据不需要垃圾清理的话，使用此GC是合理的；

# 9、ZGC垃圾收集器

ZGC的目标就是缩短Stop The World的时间：ZGC是一个并发，基于region（和G1对内存区域的管理方式一致）， 压缩型的垃圾收集器，只有root扫描阶段会Stop The World， 因此GC停顿时间不会随着堆的增长和存活对象的增长而变长。  ZGC垃圾收集器并且支持TB级内存容量，反正ZGC垃圾收集器也是Java11出现的垃圾收集器，目前开发中...
![](https://img.zouchanglin.cn///20200312/lX50PBhv0PBg.png)

9种垃圾收集器

本文主要是以通俗易懂的画图方式解释了标记清除算法和可达性分析算法，以及常用的回收算法（标记清除、标记整理、复制算法）以及整合百家之长的分代回收算法，另外还介绍了触发Full GC的几个场景。



## 标记算法

> **1、引用计数法**

回收对象之前得判断那些是需要被清除的对象，首先出现的是引用计数算法，判断对象的引用数量，通过判断对象的引用数量来决定对象是否可以被回收，每个对象实例都有一个引用计数器，被引用则+1，完成引用则-1，任何引用计数为0的对象实例可以被当作垃圾收集。

优点：执行效率高，程序执行受影响较小

缺点：无法检测出循环引用的情况，导致内存泄露

```java
public class MyObject{
    MyObject object;
    
    public static void main(String[] args) {
        MyObject myObject = new MyObject();
        MyObject myObject2 = new MyObject();
        myObject.object = myObject2;
        myObject2.object = myObject;
    }
}
```

> **2、可达性分析算法**

通过判断对象的引用链是否可达来决定对象是否可以被回收

![mark](https://img.zouchanglin.cn///20200311/1TdhcjeRK9dr.png)

可以作为GC Root的对象

1、虚拟机栈中引用的对象(栈帧中的本地变量表)

2、方法区中的常量引用的对象

3、方法区中的类静态属性引用的对象

4、本地方法栈中JNI ( Native方法)的引用对象

5、活跃线程的引用对象



## 回收算法

> **1、标记-清除（Mark and Sweep）**

没有解决内存碎片化的问题

![mark](https://img.zouchanglin.cn///20200311/5308arz5hqhL.png)

> **2、复制算法 （Copying）**

分为对象面和空闲面，对象在对象面上创建，存活的对象被从对象面复制到空闲面，将对象面所有对象内存清除，解决了内存空间碎片化的问题，合适只有少数存活对象的情况，因为只复制一小部分对象就OK了

![mark](https://img.zouchanglin.cn///20200311/nPdCkdquFenB.png)

从图中可以看出复制算法能解决碎片化问题，顺序分配内存，简单高效。适用于对象存活率低的场景。

> **3、标记整理算法（Compacting）**

标记：从根集合进行扫描，对存活的对象进行标记。清除：移动所有存活的对象，且按照内存地址次序依次排列，然后将末端内存地址以后的内存全部回收。

![mark](https://img.zouchanglin.cn///20200311/WT0zds2ysMgx.png)

标记整理算法避免内存的不连续性，不用设置两块内存互换，但是效率成问题，如果第一个对象被标记为可回收，那么剩下的对象都要往前移动，损失性能。

> **4、分代收集算法（Generational Collector）**

分代收集算法是垃圾回收算法的组合拳，按照对象生命周期的不同划分区域以采用不同的垃圾回收算法，目的在于提高JVM的回收效率。

在JDK6、JDK7中，Heap主要分为：新生代、老年代和永久代，JDK8以及以后的版本中去掉了永久代，而且使用MetaSpace替代，新生代对象存活率低，宜采用复制算法，老年代对象存活率高，采用标记清除算法或标记整理算法。

## GC的分类

Minor GC：发生在新生代中的垃圾收集动作，采用的是复制算法，新生代是垃圾收集比较频繁的区域

Full GC：一般对老年代的回收会伴随着新生代的垃圾收集

现在主要看看新生代，新生代主要分为一个Eden区和两个Survivor区（to区和from区，在垃圾收集中相互转换），对象一开始被创建的时候就是放在Eden区的，如果Eden去放不下，就会放到Survivor区甚至是老年代中。Eden区：两个Survivor区默认比例是`8:1:1` 

![mark](https://img.zouchanglin.cn///20200311/dRKnRvQqUlTe.png)

对象年龄在默认情况下超过15岁（意思是经过15次Minor GC）就会晋升到老年代，Survivor去放不下的时候也会进入到老年代中，通过设置`-XX:+PretenuserSizeThreshold` 参数来指定如果对象的大小查过指定值对象一生成就直接放入老年代，常用的性能调优的参数：

> **-XX:SurvivorRatio：Eden和Survivor的比值，默认8 : 1**
>
> **-XX:NewRatio：老年代和新生代内存大小的比例**
>
> **-XX:MaxTenuring Threshold：对象从新生代晋升到老生代经过GC次数的最大阈值**

老年代使用的最多的是标记清除算法或者标记整理算法进行垃圾回收，通常触发老年代的垃圾回收的时候也会触发新生代的垃圾回收，这便是Full GC。Full GC比Minor GC慢，但是执行的频率很低。

## 触发Full GC的条件

1、老年代空间不足

2、永久代空间不足

3、CMS GC时出现promotion failed , concurrent mode failure

当使用CMS垃圾收集器的时候，如果出现了promotion failed，那就说明在进行Minor  GC时，Survivor空间不足，对象只嗯呢该放入老年代，但是此时老年代也出现了空间不足，就会出现promotion failed，就会触发Full GC； concurrent mode failure也是CMS垃圾收集器在执行的过程中，同时有对象要放入老年代，此时老年代空间不足，就会造成concurrent mode failure，从而触发Full GC

4、Minor GC晋升到老年代的平均大小大于老年代的剩余空间，Hotspot在设计时，在进行Minor GC的时候进行了判断，如果之前统计得到的Minor GC的平均大小已经达到了老年代的剩余空间大小，就会直接触发Full GC。比如第一次Minor GC剩余的对象大小为6M，如果此时老年代剩余空间小于6M，就会触发Full GC。

5、调用System.gc()，只是提醒一下虚拟机此时应该触发Full GC，至于回不回收由虚拟机自己决定，只是System.gc()增加了Full GC的可能。

6、使用RMI来进行RPC或管理的JDK应用，每小时执行1次Full GC。

垃圾标记与收集算法

![mark](https://img.zouchanglin.cn///20200310/6jem5nNs1Jug.png)

本篇文章主要讲述了Java内存模型中的程序计数器、虚拟机栈、本地方法栈、元空间与堆，以及堆中的常量池。前面通过javap反编译class文件得到`int add(int a, int b)`函数的栈帧，主要分析了栈帧中JVM指令对应的局部变量表、操作数栈、程序计数器的状态变化。以及JDK7以后出现了替代永久代的元数据区，并分析了元数据区替换了永久代有哪些好处，主要分析了给字符串常量池带来的影响，并通过代码验证了元数据区相比永久代的优越性。学习了JVM性能调优的三个参数的意义和普通用法，最后探讨了并验证了JDK1.6与JDK1.7+的版本String类的intern方法的不同表现结果，分析了出现不同结果的原因，其实主要是JDK1.6的版本是建立副本再放入字符串常量池，而JDK1.7+版本时直接把堆上的对象的引用入池。



# 线程私有的空间

程序计数器( Program Counter Register )

1、当前线程所执行的字节码行号指示器(逻辑)

2、改变计数器的值来选取下一条需要执行的字节码指令

3、和线程是一对一的关系即：线程私有

4、对Java方法计数，如果是Native方法则计数器值为Undefined

5、由于只是对指令行号进行计数，所以不会发生内存泄漏

Java虚拟机栈（Stack）

Java虚拟机栈是Java方法执行的内存模型，包含多个栈帧，栈帧里面有哪些内容呢？

局部变量表、操作栈、动态链接、返回地址等。局部变量表包含了方法执行过程中的所有变量。操作数栈主要是：入栈、出栈、复制、交换、产生消费变量。

```java
public class ByteCodeSimple {
    public static int add(int a, int b){
        int c = 0;
        c = a + b;
        return c;
    }
}
```

通过javac编译出class文件，再通过`javap -verbose ByteCodeSimple.class`编译出如下内容：

![mark](https://img.zouchanglin.cn///20200310/QFQCc32yrrrT.png)

![mark](https://img.zouchanglin.cn///20200310/jkKALE5YcoXd.png)

每一个蓝色的长方形就代表了一个栈帧的存在状态，对应上面的代码，总共有7个栈帧状态图。

iconst指令就是将操作数0压入操作数栈中，入参为1,2因此局部变量表就是1和2。istore指令的意思就是把操作数栈的元素给pop出来，放入局部变量表的第二个变量中（因为是istore_2），iload_0就是将局部变量表中第0个的元素压入到操作数栈当中，接着又把局部变量表中第1个元素压入到操作数栈中，接着执行iadd指令（将操作数栈中的元素取出来，执行相加的操作，将结果放回栈顶），接着把栈顶的结算结果弹栈，放到局部变量表中的第二个变量里面，然后再次把局部变量表中的第二个变量放到操作数栈当中。最后调用ireturn这个指令把栈顶的元素给返回，最后执行的是销毁栈帧。

所以可以看出调用一个Java方法就是需要建立栈帧，如果递归层数过多，超出虚拟机栈的深度限制，就会引发java.lang.StackOverFlowError异常。

另一个异常就是java.lang.OutOfMemoryError，虚拟机栈过多会引发java.lang.OutOfMemoryError异常，如要尝试可以使用如下代码，**Windows测试之前请备份好重要文档**

```java
public void stackLeakByThread(){
    while (true){
        new Thread(() -> {
            while (true){

            }
        }).start();
    }
}
```

本地方法栈，与虚拟机栈相似，主要作用于标注了native的方法。

# 线程共享的空间

先说说MetaSpace（元空间）与永久代的区别：

首先，得明白方法区只是JVM的一个规范，而MetaSpace和永久代均是方法区的实现，在Java7之后，原先位于方法区的字符串常量池已经被移动到了堆中，并且在JDK8以后，使用MetaSpace替代了永久代。不仅仅只是名字上的替代：

1、元空间使用本地内存，而永久代使用的是JVM的内存，使用本地内存有什么好处呢？那就是默认的类的元数据分配只受到本地内存大小的限制，解决了空间不足的问题， 所有的被intern的String被存储在PermGen的串常量池中，解决了以前在老版本的JDK中出现的OutOfMemoryError的问题，JVM默认在运行的时候会根据需要动态的设置其大小。

2、字符串常量池存在永久代中，容易出现性能问题和内存溢出

3、永久代会为GC带来不必要的复杂性

4、方便HotSpot与其他JVM如Jrockit的集成

堆这个空间其实就是存放对象实例用的（当然也包括数组和字符串常量池）。Java堆空间可以处于物理上不连续的空间，只要逻辑是连续的即可。

# JVM三大性能调优参数

-Xms、-Xmx、-Xss

-Xss 规定了每个线程虚拟机栈的大小，一般来说256K足够用了，此配置将会影响并发线程数的大小

-Xms 堆的初始值，即进程刚创建时的堆的大小，一旦除过了堆的初始容量，将会自动扩容

-Xmx 堆能达到的最大值

通常情况下我们将 -Xms 和 -Xmx 设置成一样的，因为当堆内存不够用的时候，会发生扩容，此时会产生内存抖动，影响程序运行时的稳定性。

# 内存分配策略

1、静态存储：编译时确定每个数据目标在运行时的存储空间需求

2、栈式存储：数据区需求在编译时未知，运行时模块入口前确定，如：虚拟机栈

3、堆式存储：编译时或运行时模块入口都无法确定，动态分配，如：对象的存储和销毁

# Java内存模型中堆和栈的区别

1、管理方式：栈自动释放，堆需要GC

2、空间大小：栈比堆小

3、碎片相关：栈产生的碎片远小于堆

4、分配方式：栈支持静态和动态分配，而堆仅支持动态分配

5、效率：栈的效率比堆高

# 不同JDK版本的intern()

String对象的intern方法就是把字符串放入字符串常量池中。

JDK6：当调用intern方法时，如果字符串常量池先前已创建出该字符串对象，则返回池中的该字符串的引用。否则，将此字符串对象添加到字符串常量池中，并且返回该字符串对象的引用。

JDK6+：当调用intern 方法时，如果字符串常量池先前已创建出该字符串对象，则返回池中的该字符串的引用。否则，如果该字符串对象已经存在于Java堆中，则将堆中对此对象的引用添加到字符串常量池中，并且返回该引用;如果堆中不存在，则在池中创建该字符串并返回其引用。

> **先演示一个OutOfMemoryError：PermGen space的例子**

下面是一个一直向常量池中放入随机字符串的程序示例：

```java
public class PermGenErrTest {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            getRandomString(1000000).intern();
        }
        System.out.println("success");
    }

    private static String getRandomString(int length) {
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < length; i++) {
            int num = random.nextInt(62);
            stringBuilder.append(str.charAt(num));
        }
        return stringBuilder.toString();
    }
}
```

![mark](https://img.zouchanglin.cn///20200310/Wq89hpIpFyDG.png)

我的JDK版本选择了JDK1.6，并且配置了永久代的初始大小为6M，而且最大为6M，然后一直往常量池里面放字符串，最终出现了OutOfMemoryError：PermGen space，那么如果是换成JDK1.7+呢？

![mark](https://img.zouchanglin.cn///20200310/Dr0KF38xpzWX.png)

可以看到成功执行完毕，而且JDK1.7+是不受MaxPerSize这个参数的限制的，因为已经移除了永久代。

>**不同JDK版本的intern()**

对于JDK1.6会输出什么？JDK1.7+呢？

```java
public class InternDifference {
    public static void main(String[] args) {
        String s1 = new String("a");
        s1.intern();
        String s2 = "a";
        System.out.println(s1 == s2); 

        String s3 = new String("a") + new String("a");
        s3.intern();
        String s4 = "aa";
        System.out.println(s3 == s4);
    }
}
```

**对于JDK1.7+，输出结果是false、true**

![mark](https://img.zouchanglin.cn///20200310/kjm5UTFvcs26.png)

String s = new String("a")的时候， “a”会被首先创建，放入字符串常量池中，然后new出的对象放在堆中，在调用intern()的时候，会尝试将字符串对象放入字符串常量池中，但是发现字符串常量池中已经有了，就不能放了，在String s2 = "a"的时候，会先在常量池中寻找有没有对应的字符串，如果有，就直接返回它的引用。所以s1 == s2 比较的是字符串常量池中的"a" 的地址和堆中对象的地址，肯定是flase。在String s3 = new String("a") + new String("a")，字符串常量池是不会创建“aa”这个字符串的，因为“”中只有单个a，所以在调用intern()的时候，会尝试将“aa”也就是堆中的那个**字符串对象的引用**放入常量池中，并将该引用返回，由于这两个都是同一个地址引用，于是s3==s4是true。 

对于JDK1.6，输出结果是false、false**，如下图

![mark](https://img.zouchanglin.cn///20200310/P9m4AFFpdBEM.png)

String s1 = new String("a")的时候， “a”会被首先创建，放入字符串常量池中，然后new出的对象放在堆中，在调用intern()的时候，会尝试将字符串对象放入字符串常量池中，但是发现字符串常量池中已经有了，就不能放了，在String s2 = "a"的时候，会先在常量池中寻找有没有对应的字符串，如果有，就直接返回它的引用。所以s1 == s2 比较的是字符串常量池中的"a" 的地址和堆中对象的地址，肯定是flase。 在String s3 = new String("a") + new String("a")，字符串常量池是不会创建“aa”这个字符串的，因为“”中只有单个a，所以在调用intern()的时候，会尝试将“aa”也就是堆中的那个字符串对象放入常量池中，并返回字符串常量池中“aa”的引用，但是由于常量池中放的相当于是一个对象副本，当返回它的引用时，地址是永久区的，因此s3和s4不会相等。