java的GC与内存泄漏

Posted 2020-09-21 小虾米的java梦

从诞生至今，20多年过去，Java至今仍是使用最为广泛的语言。这仰赖于Java提供的各种技术和特性，让开发人员能优雅的编写高效的程序。今天我们就来说说Java的一项基本但非常重要的技术内存管理

了解C语言的同学都知道，在C语言中内存的开辟和释放都是由我们自己来管理的，每一个new操作都要对于一个delete操作，否则就会参数内存泄漏和溢出的问题，导致非常槽糕的后果。但在Java开发过程中，则完全不需要担心这个问题。因为jvm提供了自动内存管理的机制。内存管理的工作由jvm帮我们完成。这样我们就不用为了释放内存而头疼了。

Jvm内存浅析

虽然jvm帮我们做了内存管理的工作，但是我们仍需要了解jvm到底做了什么，下面我们就一起去看一看

jvm启动时进行一系列的工作，其中一项就是开辟一块运行时内存。而这一块内存中又分为了五大区域，分别用于不同的功能。

 

 

程序计数器

 记录程序运行的下一条指令的地址，这里的“地址”可以是一个本地指针，也可以是在方法字节码中相对于该方法起始指令的偏移量。如果该线程正在执行一个本地方法，那么此时程序计数器的值为”undefined”.在多线程环境下，每一个线程都有自己的程序计数器，在jvm调度线程时，会把当前的线程的程序计数器保存到快照，以便下次线程获取执行时间时获取

VM Stack

虚拟机栈是Java方法执行的内存模型，每个方法执行的时候，会在栈中创建一帧用于存储局部变量表、操作数栈、动态链接、方法出口。方法开始调用时，会创建栈帧并入栈，方法执行结束时会出栈。每个线程都有自己的栈。

动态链接：是一种在常量池中指向方法的符号引用，需要在运行期确定为直接引用

方法出口：当前执行方法的调用者的程序计数器，或异常处理表的地址

可以通过 -xxs 大小 来配置栈的大小，当嵌套调用使用不当，会导致方法不停的入栈，最终导致栈空间被占满产生 StackOverflowError

本地方法栈

Heap

堆是用于存放对象实例的地方，几乎所有对象实例在堆中分配。堆是线程共享的，这是多线程时同步机制的原因。

堆是GC管理的主要区域，GC在对堆进行回收前，首先要确定对象是否已死（不可能再被使用的对象）

判断对象是否存活的算法有两种：引用计数算法、可达性分析算法

引用计数算法是为每一个对象添加一个引用计数器，每当有一个引用指向它时，计数器就加一，任何时刻计数器为0的对象就不可能再被使用。这种算法实现简单，但是它很难解决对象循环引用的问题(何为循环引用见下方备注)

可达性分析算法是Java语言正在使用的算法。它的基本思想是通过一系统被称为“GC Root”的对象为起点，从这个起点向下搜索，搜索走过的路径称为引用链，当一个对象不再任何引用链上时，则说明这个对象是不可能再被使用的。

在Java语言中，GC Root包括以下几种对象：

1. 虚拟机栈中引用的对象
2. 本地方法栈中JNI引用的对象
3. 方法区中类静态成员变量引用的对象
4. 方法区中常量引用的对象

可以看出分析对象是否存活，都与引用有关。在JDK1.2之后，Java对引用的概念进行了扩充，将引用分为 强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)、虚引用(Phantom Reference)

1. 强引用

强引用即为原来意义上的引用，只要强引用存在，被引用的对象就不会被回收

1. 软引用

SoftReference类表示软引用，对于被软引用关联的对象，在系统将要发生内存溢出时，会把这些对象列入回收范围后，进行二次回收

1. 弱引用

WeakReference类表示弱引用，对于被弱引用关联的对象，只能生存到下一次垃圾回收发生之前

1. 虚引用

PhantomReference类表示虚引用，虚引用不对关联的对象的生存时间构成影响，也无法取得对象实例，它唯一的作用是在对象被GC回收是收到一条系统通知

堆得大小可以通过-Xmx和-Xms来控制。对于主流的Jvm，GC基本都采用分代收集的算法。基于这个算法， Java堆又分为新生代(Young Generation)和老年代(Old Generation)，新生代又被进一步划分为Eden和Survivor区，最后Survivor由FromSpace和ToSpace组成。新建的对象都是用新生代分配内存，Eden空间不足的时候，会把存活的对象转移到Survivor中，新生代大小可以由-Xmn来控制，也可以用-XX:SurvivorRatio来控制Eden和Survivor的比例。老生代用于存放新生代中经过多次垃圾回收(也即Minor GC)仍然存活的对象。

永生代(Permanent Space)为方法区

 

 

方法区

方法区也为所以线程所共享，用于存放已加载的类信息、静态变量、常量和即时编译器编译后的代码。-XX:MaxPermSize用于设置方法区大小

直接内存

直接内存不是虚拟机运行时数据区的一部分。通过Native函数库直接分配的堆外内存，然后通过存储在Java堆中的DirectByteBuffer对象作为这块内存的引用进行操作

内存分配和回收策略

目前为止，jvm已经发展处三种比较成熟的垃圾收集算法：1.标记-清除算法；2.复制算法；3.标记-整理算法；4.分代收集算法

1．        标记-清除算法

这种垃圾回收一次回收分为两个阶段：标记、清除。首先标记所有需要回收的对象，在标记完成后回收所有被标记的对象。这种回收算法会产生大量不连续的内存碎片，当要频繁分配一个大对象时，jvm在新生代中找不到足够大的连续的内存块，会导致jvm频繁进行内存回收(目前有机制，对大对象，直接分配到老年代中)

2．        复制算法

这种算法会将内存划分为两个相等的块，每次只使用其中一块。当这块内存不够使用时，就将还存活的对象复制到另一块内存中，然后把这块内存一次清理掉。这样做的效率比较高，也避免了内存碎片。但是这样内存的可使用空间减半，是个不小的损失。

3．        标记-整理算法

这是标记-清除算法的升级版。在完成标记阶段后，不是直接对可回收对象进行清理，而是让存活对象向着一端移动，然后清理掉边界以外的内存

4．        分代收集算法

当前商业虚拟机都采用这种算法。首先根据对象存活周期的不同将内存分为几块即新生代、老年代，然后根据不同年代的特点，采用不同的收集算法。在新生代中，每次垃圾收集时都有大量对象死去，只有少量存活，所以选择了复制算法。而老年代中因为对象存活率比较高，所以采用标记-整理算法(或者标记-清除算法)

GC的执行机制

由于对象进行了分代处理，因此垃圾回收区域、时间也不一样。GC有两种类型：Scavenge GC和Full GC。

　　Minor GC

　　一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Minor GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对年轻代的Eden区进行，不会影响到年老代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、效率高的算法，使Eden去能尽快空闲出来。

　　Full GC

　　对整个堆进行整理，包括Young、Tenured和Perm。Full GC因为需要对整个堆进行回收，所以比Minor GC要慢，因此应该尽可能减少Full GC的次数。在对JVM调优的过程中，很大一部分工作就是对于FullGC的调节。有如下原因可能导致Full GC：

　　1.年老代（Tenured）被写满

　　2.持久代（Perm）被写满

　　3.System.gc()被显示调用

     4.上一次GC之后Heap的各域分配策略动态变化

Java常见的内存泄漏

1. 数据库连接，网络连接，IO连接等没有显示调用close关闭，会导致内存泄露
2. 监听器的使用，在释放对象的同时没有相应删除监听器的时候也可能导致内存泄露

 

JAVA是垃圾回收语言的一种，开发者无需特意管理内存分配。但是JAVA中还是存在着许多内存泄露的可能性，如果不好好处理内存泄露，会导致APP内存单元无法释放被浪费掉，最终导致内存全部占据堆栈(heap)挤爆进而程序崩溃。

内存泄露

说到内存泄露，就不得不提到内存溢出，这两个比较容易混淆的概念，我们来分析一下。

• 内存泄露：程序在向系统申请分配内存空间后(new)，在使用完毕后未释放。结果导致一直占据该内存单元，我们和程序都无法再使用该内存单元，直到程序结束，这是内存泄露。

• 内存溢出：程序向系统申请的内存空间超出了系统能给的。比如内存只能分配一个int类型，我却要塞给他一个long类型，系统就出现oom。又比如一车最多能坐5个人，你却非要塞下10个，车就挤爆了。

大量的内存泄露会导致内存溢出(oom)。

内存

想要了解内存泄露，对内存的了解必不可少。
JAVA是在JVM所虚拟出的内存环境中运行的，JVM的内存可分为三个区：堆(heap)、栈(stack)和方法区(method)。

• 栈(stack)：是简单的数据结构，但在计算机中使用广泛。栈最显著的特征是：LIFO(Last In, First Out, 后进先出)。比如我们往箱子里面放衣服，先放入的在最下方，只有拿出后来放入的才能拿到下方的衣服。栈中只存放基本类型和对象的引用(不是对象)。

• 堆(heap)：堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。JVM只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身。

• 方法区(method)：又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。

内存的概念大概理解清楚后，要考虑的问题来了：
到底是哪里的内存会让我们造成内存泄露？

 

 

内存泄露原因分析

在JAVA中JVM的栈记录了方法的调用，每个线程拥有一个栈。在线程的运行过程当中，执行到一个新的方法调用，就在栈中增加一个内存单元，即帧(frame)。在frame中，保存有该方法调用的参数、局部变量和返回地址。然而JAVA中的局部变量只能是基本类型变量(int)，或者对象的引用。所以在栈中只存放基本类型变量和对象的引用。引用的对象保存在堆中。

当某方法运行结束时，该方法对应的frame将会从栈中删除，frame中所有局部变量和参数所占有的空间也随之释放。线程回到原方法继续执行，当所有的栈都清空的时候，程序也就随之运行结束。

而对于堆内存，堆存放着普通变量。在JAVA中堆内存不会随着方法的结束而清空，所以在方法中定义了局部变量，在方法结束后变量依然存活在堆中。

综上所述，栈(stack)可以自行清除不用的内存空间。但是如果我们不停的创建新对象，堆(heap)的内存空间就会被消耗尽。所以JAVA引入了垃圾回收(garbage collection，简称GC)去处理堆内存的回收，但如果对象一直被引用无法被回收，造成内存的浪费，无法再被使用。所以对象无法被GC回收就是造成内存泄露的原因！

垃圾回收机制

垃圾回收(garbage collection，简称GC)可以自动清空堆中不再使用的对象。在JAVA中对象是通过引用使用的。如果再没有引用指向该对象，那么该对象就无从处理或调用该对象，这样的对象称为不可到达（unreachable）。垃圾回收用于释放不可到达的对象所占据的内存。

实现思想：我们将栈定义为root，遍历栈中所有的对象的引用，再遍历一遍堆中的对象。因为栈中的对象的引用执行完毕就删除，所以我们就可以通过栈中的对象的引用，查找到堆中没有被指向的对象，这些对象即为不可到达对象，对其进行垃圾回收。

垃圾回收实现思想

如果持有对象的强引用，垃圾回收器是无法在内存中回收这个对象。

引用类型

在JDK 1.2以前的版本中，若一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及(reachable)状态，程序才能使用它。从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。
Java/Android引用类型及其使用分析

1. 强引用(Strong reference)
实际编码中最常见的一种引用类型。常见形式如：A a = new A();等。强引用本身存储在栈内存中，其存储指向对内存中对象的地址。一般情况下，当对内存中的对象不再有任何强引用指向它时，垃圾回收机器开始考虑可能要对此内存进行的垃圾回收。如当进行编码：a = null，此时，刚刚在堆中分配地址并新建的a对象没有其他的任何引用，当系统进行垃圾回收时，堆内存将被垃圾回收。

2. 软引用(Soft Reference)
软引用的一般使用形式如下：

A a = new A();
SoftReference<A> srA = new SoftReference<A>(a);

软引用所指示的对象进行垃圾回收需要满足如下两个条件：
1.当其指示的对象没有任何强引用对象指向它；
2.当虚拟机内存不足时。
因此，SoftReference变相的延长了其指示对象占据堆内存的时间，直到虚拟机内存不足时垃圾回收器才回收此堆内存空间。

3. 弱引用(Weak Reference)
同样的，软引用的一般使用形式如下：

A a = new A();
WeakReference<A> wrA = new WeakReference<A>(a);

WeakReference不改变原有强引用对象的垃圾回收时机，一旦其指示对象没有任何强引用对象时，此对象即进入正常的垃圾回收流程。

4. 虚引用(Phantom Reference)
与SoftReference或WeakReference相比，PhantomReference主要差别体现在如下几点：
1.PhantomReference只有一个构造函数

PhantomReference(T referent, ReferenceQueue<? super T> q)

2.不管有无强引用指向PhantomReference的指示对象，PhantomReference的get()方法返回结果都是null。

因此，PhantomReference使用必须结合ReferenceQueue；
与WeakReference相同，PhantomReference并不会改变其指示对象的垃圾回收时机。

内存泄露原因

如果持有对象的强引用，垃圾回收器是无法在内存中回收这个对象。

内存泄露的真因是：持有对象的强引用，且没有及时释放，进而造成内存单元一直被占用，浪费空间，甚至可能造成内存溢出！

其实在android中会造成内存泄露的情景无外乎两种：

• 全局进程(process-global)的static变量。这个无视应用的状态，持有Activity的强引用的怪物。
• 活在Activity生命周期之外的线程。没有清空对Activity的强引用。

检查一下你的项目中是否有以下几种情况：

• Static Activities
• Static Views
• Inner Classes
• Anonymous Classes
• Handler
• Threads
• TimerTask
• Sensor Manager