垃圾回收相关概念
# JVM-垃圾回收相关概念
# 1. System.gc()的理解
在默认情况下,通过System.()或者Runtime.getRuntime().gc()的调用,会显式触发Full GC
,同时对老年代和新生代进行回收,尝试释放被丢弃对象占用的内存。
然而System.gc()调用附带一个免责声明,无法保证对垃圾收集器的调用。
JVM实现者可以通过System.gc()调用来决定JVM的GC行为。而一般情况下,垃圾回收应该是自动进行的,无序手动触发,否则就太过于麻烦了。在一些特殊情况下,如我们正在编写一个性能基准,我们可以在运行质检调用System.gc()。
# 示例1
public class SystemGCTest {
public static void main(String[] args) {
new SystemGCTest();
System.gc();//提醒jvm的垃圾回收器执行gc,但是不确定是否马上执行gc
//与Runtime.getRuntime().gc();的作用一样。
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("SystemGCTest 重写了finalize()");
}
}
2
3
4
5
6
7
8
9
10
11
12
13
结果:多次执行没有调用 finalize()
,偶尔会执行 finalize()
.
提醒jvm的垃圾回收器执行gc,但是不确定是否马上执行gc
# 示例2
public class SystemGCTest {
public static void main(String[] args) {
new SystemGCTest();
System.gc();//提醒jvm的垃圾回收器执行gc,但是不确定是否马上执行gc
//与Runtime.getRuntime().gc();的作用一样。
System.runFinalization();//强制调用使用引用的对象的finalize()方法
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("SystemGCTest 重写了finalize()");
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
System.runFinalization(): 强制调用使用引用的对象的finalize()方法
# 示例3:手动gc理解不可达对象的回收行为
-XX:+PrintGCDetails
# 1. 示例一
public class LocalVarGC {
public void localvarGC1() {
byte[] buffer = new byte[10 * 1024 * 1024];//10MB
System.gc();
}
public static void main(String[] args) {
LocalVarGC local = new LocalVarGC();
local.localvarGC1();
}
}
2
3
4
5
6
7
8
9
10
11
结果:未进行垃圾回收
# 2. 示例二
public class LocalVarGC {
public void localvarGC2() {
byte[] buffer = new byte[10 * 1024 * 1024];
buffer = null;
System.gc();
}
public static void main(String[] args) {
LocalVarGC local = new LocalVarGC();
local.localvarGC2();
}
}
2
3
4
5
6
7
8
9
10
11
12
结果:进行垃圾回收
# 3. 示例三
public class LocalVarGC {
public void localvarGC3() {
{
byte[] buffer = new byte[10 * 1024 * 1024];
}
System.gc();
}
public static void main(String[] args) {
LocalVarGC local = new LocalVarGC();
local.localvarGC3();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
结果:未进行垃圾回收
# 4. 示例四
public class LocalVarGC {
public void localvarGC4() {
{
byte[] buffer = new byte[10 * 1024 * 1024];
}
int value = 10;
System.gc();
}
public static void main(String[] args) {
LocalVarGC local = new LocalVarGC();
local.localvarGC4();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
结果:进行垃圾回收
# 5. 示例五
public class LocalVarGC {
public void localvarGC5() {
localvarGC1();
System.gc();
}
public static void main(String[] args) {
LocalVarGC local = new LocalVarGC();
local.localvarGC5();
}
}
2
3
4
5
6
7
8
9
10
11
结论:进行垃圾回收
# 2. 内存溢出与内存泄露
# 1. 内存溢出(OOM)
内存溢出相对于内存泄露来说,尽管更容易被理解,单是同样的,内存溢出也是引发程序崩溃的罪魁祸首之一。
由于GC一直在发展,所有一般情况下,除非应用程序占用的内存增长速度非常快,造成垃圾回收已经跟不上内存消耗的速度,否则不太容易出现OOM的情况。
大多数情况下,GC会进行各种年龄段的垃圾回收,实在不行了就放大招,来一次独占式的Full GC操作,这时候会回收大量的内存,供应用程序继续使用。
javadoc中对OutOfMenoryError的解释是:
没有空闲内存,并且垃圾收集器也无法提供更多内存。
首先说没有空闲内存的情况:说明Java虚拟机的堆内存不够。
- Java虚拟机的堆内存设置不够
比如:可能存在内存泄露问题;也很有可能就是堆的大小不合理,比如我们要处理比较可观的数据量,但是没有显式指定JVM堆大小或者指定数值偏小。我们可以通过参数-Xms、-Xmx来调整。
- 代码中创建了大量大对象,并且长时间不能被垃圾收集器收集(存在被引用)
对于老版本的Oracle JDK,因为永久代的大小是有限的,并且JVM对永久代垃圾回收(如:常量池回收、卸载不在需要的类型)非常不积极,所以当我们不断添加新类型的时候,永久代出现OutOfMenoryError也非常多见,尤其是在运行时存在大量动态类型生成的场合;李四intern字符串缓存占用太多空间,也会导致OOM问题。对应的异常信息,会标寄出来和永久代相关:“Java.lang.OurOfMemoryError: PermGen space".
随着元数据区的引入,方法区内存已经不再那么窘迫,所以响应的OOM有所改观,出现OOM,异常信息则变成了:ava.lang.OurOfMemoryError: PermGen space".直接内存不足,也会导致OOM。
这里面隐含着一层意思是,在抛出OutOfMemoryError之前,通常垃圾收集器会被触发,近期所能去清理空间
- 例如:在引用机制分析中,涉及到JVM会去尝试回收软引用指向的对象等。
- 在java.nio.BIts.reserveMemory()方法中,我们能够清楚的看到,System.gc()会被调用,已清理空间。
当然,也不是在任何情况下垃圾收集器都会被触发的
比如,我们去分配一个超大对象,类似一个超大数组超过谁的最大值,JVM可以判定出垃圾收集并不能解决这个问题,所以直接抛出OutOfMemoryError。
# 2. 内存泄漏(Memoy Leak)
Java使用可达性分析算法
也称作“存储渗漏”。
严格来说,只有对象不会再被程序用到了,但是GC又不能回收它们的情况,才叫内存泄露。
但实际情况很多时候一些不太好的实践(或疏忽)会导致对象的生命周期变的很长甚至导致OOM,也可以叫做
宽泛意义上的“内存泄露”。
尽管内存泄露并不会立刻引起程序崩溃,但是一旦发生泄漏,程序中的可用内存就会逐步蚕食,直至耗尽所有内存,最庸出现OutOfMemory异常,导致程序崩溃。
注意:这里的存储空间并不是指物理内存,而是指虚拟内存大小,这个虚拟内存大小取决于磁盘交换区设定的大小。
# 内存泄漏举例
# 1. 单例模式
单例的生命周期和应用程序是一样长的,所以单例程序中,如果持有对外部对象的引用的话,那么这个外部对象是不能被回收的,则会导致内存泄露的产生。Runtime
# 2. 一些提供close的资源未关闭导致内存泄露
数据库连接(dateSource.getConnection()),玩过连接(socket)和io连接必须手动close,否则是不能被回收的。
# 3. Stop The World
Stop-the-world简称“STW”,值的是GC事件发生过程中,会产生应用程序的停顿。停顿产生是整个应用程序线程都会被暂停,没有任何响应,有点像卡死的感觉,这个停顿称为STW。
可达性分析算法中枚举根结点(GC Roots)会导致所有Java执行线程停顿。
- 分析工作必须在一个能确保一致性的快照中进行
- 一致性指整个分析期间整个执行系统看起来像被冻结在某个时间点上
- 如果出现分析过程中对象引用关系还在不断变化,则分析结果的准确性无法保证。
被STW中断的应用程序会在完成GC之后恢复,频繁中断会让用户感觉像是网速不快造成电影卡带一样,所以我们需要减少STW的发生。
STW事件和采用那款GC无关,所有的GC都有这个事件。
哪怕是G1也不能完全避免STW情况发生,只能说垃圾收集器越来越优秀没回收效率越来越高,尽可能的缩短了暂停时间。
STW是JVM在后台自动发起和自动完成的。在用户不可见的情况下,把用户正常的工作线程全部停掉。
开发中不要用System.gc();会导致STM的发生。
# 示例
public class StopTheWorldDemo {
public static class WorkThread extends Thread {
List<byte[]> list = new ArrayList<byte[]>();
public void run() {
try {
while (true) {
for(int i = 0;i < 1000;i++){
byte[] buffer = new byte[1024];
list.add(buffer);
}
if(list.size() > 10000){
list.clear();
System.gc();//会触发full gc,进而会出现STW事件
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
public static class PrintThread extends Thread {
public final long startTime = System.currentTimeMillis();
public void run() {
try {
while (true) {
// 每秒打印时间信息
long t = System.currentTimeMillis() - startTime;
System.out.println(t / 1000 + "." + t % 1000);
Thread.sleep(1000);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
public static void main(String[] args) {
WorkThread w = new WorkThread();
PrintThread p = new PrintThread();
w.start();
p.start();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
不添加system.gc() 有规律1s一次
添加system.gc()
# 4. 垃圾回收的并行与并发
# 1. 并发(Concurrent)
在操作系统中,是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理器上运行。
并发不是真正意义上的“同时进行”
只是CPU把同一个时间段划分成几个实际那片段(时间区间),然后在这几个时间区间来回切换,忧郁CPU处理的速度非常快,只要时间间隔处理得当,即可让用户感觉是多个应用程序同时在运行。
# 2. 并行(Parallel)
当两个系统有一个以上CPU时,当一个CPU执行一个进程时,另一个CPU可以执行另一个程序,两个进程互不抢占资源,可以同时进行,我们称之为并行。
其实决定并行的因素不是CPU数量,而是CPU的核心数量,比如一个CPU多个核也可以并行。
适合科学计算,后台处理等弱交互场景。
# 3. 并发 VS 并行
# 二者对比
并发:指的是多个事情,在同一个时间段内同时发生了。
并行:指的是多个事情,在同一个时间点上同时发生了。
并发的多个任务之间是互相抢占资源的。
并行的多个任务之间是不互相抢占资源的。
只要在多CPU或者一个CPU多核的情况下,才会发生并行。
否则,看似同时发生的事情,其实都是并发执行的。
# 4. 垃圾回收的并行与并发
并行和并发,在谈论垃圾收集器的上下文语境中,它们可以解释如下:
并行:指多条垃圾收集线程并行工作,但此时用户线程仍处于等待状态。
如:ParNew、Parallel、Scavenge、Parallel Old;
串行(Serial)
- 相较于并行的概念,单线程执行。
- 如果内存不够,则程序暂停,启动JVM垃圾回收器进行垃圾回收,回收万,再启动程序的线程。
- 并发:指用户线程与垃圾收集线程同时执行(但不一定是并行的,可能会交替执行),垃圾回收线程在执行时不会停顿用户程序的运行。
- 用户程序在继续运行,而垃圾收集程序线程运行于另一个CPU上;
- 如: CMS、G1
# 5. 安全点与安全区域
# 1. 安全点(Safepoint)
程序执行时并非所有地方都能停顿下来开始GC,只有在特定的位置才能停顿下来开始GC,这些位置称为“安全点(Safepoint)"。
Safe Point的选择很重要,如果太少可能导致GC等待的时间太长,如果太频繁可能导致运行时的性能问题。大部分指令的执行时间都非常短暂,通常会根据”是否具有让程序长时间执行的特性
“为标准。比如:选择一些执行时间较长的指令作为Safe Point,如方法调用,循环跳转和异常跳转等。
# 如何在GC发生时,检查所有线程都跑到最近的安全点停顿下来能?
抢占式中断:(目前没有虚拟机采用了)
收线中断所有线程。如果还有线程不在安全点,就恢复线程,让线程跑到安全点。
主动式中断:
设置一个中断标志,各个线程运行到Safe Point的时候主动轮询这个标志,如果中断标志为真,则将自己进行中断挂起。
# 2. 安全区域
Safepoint机制保证了程序执行时,在不太长的时间内就会遇到可进入GC的Safepoint。但是,程序”不执行“的时候能?例如线程处于Sleep状态或者Blocked状态,这个时候线程无法响应JVM的中断请求,”走“到安全点去中段挂起,JVM也不太可能等待贤臣被唤醒。对于这种情况,就需要安全区域(Safe Region)来解决。 安全区域是指在一段代码片段中,对象的引用关系不会变化,在这个区域中的任何位置开始GC都是安全的。我们也可以把Safe Region看做是被扩展了的Safepoint。
# 实际执行时:
- 当线程云心到Safe Region的代码时,首先表示已经进入Safe Region,如果这段时间内发生GC,JVM会忽略标识为Safe Region状态的线程;
- 当线程即将离开Safe Region时,会检查JVM是否已经完成GC,如果完成了,则继续运行,否则线程必须等待直接收到可以安全离开Safe Region的信号为止。
# 6. 再谈引用
# 0. 再谈引用
我们希望能够描述这样一类对象:当内存空间还足够时,则能保留在内存中;如果内存空间在进行垃圾收集后还是很紧张,则可以抛弃这些对象。
# 【即偏门有非常高频的面试题】强引用、软引用、弱引用、虚引用有什么区别?具体使用场景是什么?
在JDK1.2版之后,Java对应用的概念进行了扩充,将引用分为强引用(Strong Reference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种,这四种引用强度依次逐渐减弱。
除强引用外,其他2种引用均可以在java.lang.ref包中找到它们的身影。如下图,显示着3种引用类型对应的类,开发人员可以在应用程序中直接使用它们。
Reference子类中只有终结器引用(Final Reference)是包内可见的,其他3种引用类型均为public,可以在应用程序中直接使用
- 强引用 Strong Reference
强引用开发中占99%以上。
最传统的"引用"的定义:在程序代码之中普遍存在的引用赋值,即类“Object obj = new objct()"这种引用关系。无论任何情况下,只要强引用关系还在,垃圾收集器就永远不会回收掉引用的对象。
- 软引用 Soft Reference
在系统将要发生内存溢出之前,将会把这些对象列入回收范围之中及逆行第二次回收,如果这次回收后还没有足够的内存,才会抛出内存溢出
异常。
- 弱引用 Weak Reference
被弱引用关联的对象只能生存到下一个垃圾收集之前。当垃圾收集器工作时,无论内存空间是否足够,都会回收掉被弱引用关联的对象。
- 虚引用 Phantom Reference
一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来获得一个对象的实例。为一个对象设置引用关联的唯一目的就是内在这个对象被收集器回收时收到一个通知
。
# 1. 强引用 Strong Reference--不回收
在Java程序中,最常见的引用类型是强引用(普通系统99%以上都是强引用
),也就是我们最常见的普遍对象引用,也是默认的引用类型
。
当在Java语言中使用new操作符创建一个新的对象,并将其赋值给一个变量的时候,这个变量就成为指向该对象的一个强引用。
强引用的对象是可触及的,垃圾收集器就永远不会回收掉引用的对象。
对于一个普通的对象,如果没有其他的引用关系,只要超过了作用的作用域或者显示地将相应(强)引用赋值为null,就是可以当做垃圾被手机了,当然具体回收时机还是要看垃圾收集策略。
相对的,软引用如引用和虚引用的对象是软可触及、若可触及、和虚可触及的,在一定条件下,都是可以被回收的。所以,强引用是造成Java内存泄露的主要原因之一。