转载:
https://www.bilibili.com/video/BV1PJ411n7xZ
参考:
https://gitee.com/moxi159753/LearningNotes/tree/master/JVM,
https://www.cnblogs.com/yanl55555/p/12623447.html
public class SystemGCTest {
public static void main(String[] args) {
new SystemGCTest();
System.gc();//提醒jvm的垃圾回收器执行gc,但是不确定是否马上执行gc
//与Runtime.getRuntime().gc();的作用一样。
// System.runFinalization();//强制调用 失去引用的对象的finalize()方法
System.out.println("结束");
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("SystemGCTest 重写了finalize()");
}
// 注释runFinalization
// 结束 和 SystemGCTest 重写了finalize()顺序不一定
// 不注释runFinalization
// 一定 结束 和 SystemGCTest 重写了finalize()顺序
}
我们调用System.gc()的时候,其实并不会马上进行垃圾回收,甚至不一定会执行垃圾回收
public class LocalVarGC {
/**
* 触发YoungGC没有回收对象,进入s0或s1
* 触发Full GC将该对象存入old区
*/
public void localvarGC1() {
byte[] buffer = new byte[10*1024*1024];
System.gc();
}
/**
* 触发YoungGC的时候,已经被回收了
*/
public void localvarGC2() {
byte[] buffer = new byte[10*1024*1024];
buffer = null;
System.gc();
}
/**
* 不会被回收,因为它还存放在局部变量表索引为1的slot
*/
public void localvarGC3() {
{
byte[] buffer = new byte[10*1024*1024];
}
System.gc();
}
/**
* 会被回收,因为它还存放在局部变量表索引为1的slot,但是后面定义的value把这个槽给替换了
*/
public void localvarGC4() {
{
byte[] buffer = new byte[10*1024*1024];
}
int value = 10;
System.gc();
}
/**
* localvarGC5中的数组已经被回收
*/
public void localvarGC5() {
localvarGC1();
System.gc();
}
public static void main(String[] args) {
LocalVarGC localVarGC = new LocalVarGC();
localVarGC.localvarGC5();
}
}
内存溢出相对于内存泄漏来说,尽管更容易被理解,但是同样的,内存溢出也是引发程序崩溃的罪魁祸首之一。
由于GC一直在发展,所有一般情况下,除非应用程序占用的内存增长速度非常快,造成垃圾回收已经跟不上内存消耗的速度,否则不太容易出现ooM的情况。
大多数情况下,GC会进行各种年龄段的垃圾回收,实在不行了就放大招,来一次独占式的Fu11GC操作,这时候会回收大量的内存,供应用程序继续使用。
javadoc中对outofMemoryError的解释是,没有空闲内存,并且垃圾收集器也无法提供更多内存。
首先说没有空闲内存:说明Java虚拟机的堆内存不够。原因有二:
Java虚拟机的堆内存设置不够。
比如:可能存在内存泄漏问题;也很有可能就是堆的大小不合理,比如我们要处理比较可观的数据量,但是没有显式指定JVM堆大小或者指定数值偏小。我们可以通过参数-Xms 、-Xmx来调整。
代码中创建了大量大对象,并且长时间不能被垃圾收集器收集(存在被引用)
① 对于老版本的oracle JDK,因为永久代的大小是有限的,并且JVM对永久代垃圾回收(如,常量池回收、卸载不再需要的类型)非常不积极,所以当我们不断添加新类型的时候,永久代出现OutOfMemoryError也非常多见,尤其是在运行时存在大量动态类型生成的场合;类似intern字符串缓存占用太多空间,也会导致OOM问题。对应的异常信息,会标记出来和永久代相关:“java.lang.OutOfMemoryError:PermGen space"。
② 随着元数据区的引入,方法区内存已经不再那么窘迫,所以相应的ooM有所改观,出现ooM,异常信息则变成了:“java.lang.OutofMemoryError:Metaspace"。直接内存不足,也会导致OOM。
在抛出OutofMemoryError之前,通常垃圾收集器会被触发,尽其所能去清理出空间。列如:
① 在引用机制分析中,涉及到JVM会去尝试回收软引用指向的对象等。
② 在java.nio.BIts.reserveMemory()方法中,我们能清楚的看到,System.gc()会被调用,以清理空间。
当然,也不是在任何情况下垃圾收集器都会被触发的
比如,我们去分配一个超大对象,类似一个超大数组超过堆的最大值,JVM可以判断出垃圾收集并不能解决这个问题,所以直接抛出OutofMemoryError。
注意,这里的存储空间并不是指物理内存,而是指虚拟内存大小,这个虚拟内存大小取决于磁盘交换区设定的大小。
Java使用可达性分析算法,最上面的数据不可达,就是需要被回收的。后期有一些对象不用了,按道理应该断开引用,但是存在一些链没有断开,从而导致没有办法被回收。
单例模式
单例的生命周期和应用程序是一样长的,所以单例程序中,如果持有对外部对象的引用的话,那么这个外部对象是不能被回收的,则会导致内存泄漏的产生。
一些提供close的资源未关闭导致内存泄漏
数据库连接(dataSourse.getConnection() ),网络连接(socket)和io连接必须手动close,否则是不能被回收的。
Stop-The-World,简称STW,指的是GC事件发生过程中,会产生应用程序的停顿。停顿产生时整个应用程序线程都会被暂停,没有任何响应,有点像卡死的感觉,这个停顿称为STW。
可达性分析算法中枚举根节点(GC Roots)会导致所有Java执行线程停顿。
被STW中断的应用程序线程会在完成GC之后恢复,频繁中断会让用户感觉像是网速不快造成电影卡带一样,所以我们需要减少STw的发生。
STW事件和采用哪款GC无关所有的GC都有这个事件。
哪怕是G1也不能完全避免Stop-the-world情况发生,只能说垃圾回收器越来越优秀,回收效率越来越高,尽可能地缩短了暂停时间。
STW是JVM在后台自动发起和自动完成的。在用户不可见的情况下,把用户正常的工作线程全部停掉。
开发中不要用system.gc() 会导致stop-the-world的发生。
类似串字
并行:多个垃圾回收线程同时进行
并发:用户线程和垃圾回收线程同时进行
并发的多个任务之间是互相抢占资源的。并行的多个任务之间是不互相抢占资源的。
只有在多CPU或者一个CPU多核的情况中,才会发生并行。
否则,看似同时发生的事情,其实都是并发执行的。
并发和并行,在谈论垃圾收集器的上下文语境中,它们可以解释如下:
并发和并行,在谈论垃圾收集器的上下文语境中,它们可以解释如下:
**安全区域是指在一段代码片段中,对象的引用关系不会发生变化,在这个区域中的任何位置开始Gc都是安全的。**我们也可以把Safe Region看做是被扩展了的Safepoint。
强引用,软引用,弱引用都是基于引用关系还存在
StringBuffer str = new StringBuffer("hello mogublog");
StringBuffer str = new StringBuffer("hello mogublog");
StringBuffer str1 = str;
那么我们将 str = null; 则 原来堆中的对象也不会被回收,因为还有其它对象指向该区域
本例中的两个引用,都是强引用,强引用具备以下特点:
软引用是用来描述一些还有用,但非必需的对象。只被软引用关联着的对象,在系统将要发生内存溢出异常前,会把这些对象列进回收范围之中进行第二次回收,如果这次回收还没有足够的内存,才会抛出内存溢出异常。
软引用通常用来实现内存敏感的缓存。比如:高速缓存就有用到软引用。如果还有空闲内存,就可以暂时保留缓存,当内存不足时清理掉,这样就保证了使用缓存的同时,不会耗尽内存。
垃圾回收器在某个时刻决定回收软可达的对象的时候,会清理软引用,并可选地把引用存放到一个引用队列(Reference Queue)。
类似弱引用,只不过Java虚拟机会尽量让软引用的存活时间长一些,迫不得已才清理。
软引用:
在JDK1.2版之后提供了SoftReference类来实现软引用
// 声明强引用
Object obj = new Object();
// 创建一个软引用
SoftReference
public static void main(String[] args) {
//创建对象,建立软引用
SoftReference userSoftRef = new SoftReference(new User(1, "songhk"));
//上面的一行代码,等价于如下的三行代码
// User u1 = new User(1,"songhk");
// SoftReference userSoftRef = new SoftReference(u1);
// u1 = null;//取消强引用
//从软引用中重新获得强引用对象
System.out.println(userSoftRef.get());
System.gc();
System.out.println("System.gc后");
// //垃圾回收之后获得软引用中的对象
System.out.println(userSoftRef.get());//由于堆空间内存足够,所有不会回收软引用的可达对象。
try {
System.out.println("-Xms10m -Xmx10m -XX:+PrintGCDetails");
//让系统认为内存资源紧张、不够
byte[] b = new byte[1024 * 1024 * 10];
// byte[] b = new byte[1024 * 1024 * xx];//一定的分配的内存大小,既可以不报OOM,同时恰巧接纳不了软引用的内存大小
} catch (Throwable e) {
e.printStackTrace();
} finally {
//再次从软引用中获取数据
System.out.println(userSoftRef.get());//在报OOM之前,垃圾回收器会回收软引用的可达对象。打印为null
}
}
}
软引用不会导致内存溢出OOM
// 声明强引用
Object obj = new Object();
// 创建一个弱引用
WeakReference
/**
* 弱引用的测试:发现即回收
*/
public class WeakReferenceTest {
public static class User {
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int id;
public String name;
@Override
public String toString() {
return "[id=" + id + ", name=" + name + "] ";
}
}
public static void main(String[] args) {
//创建对象,建立弱引用
// WeakReference userSoftRef = new WeakReference(new User(1, "songhk"));
//上面的一行代码,等价于如下的三行代码
User u1 = new User(1,"songhk");
WeakReference userSoftRef = new WeakReference(u1);
u1 = null;//取消强引用
//从弱引用中重新获得强引用对象
System.out.println(userSoftRef.get());
System.gc();
System.out.println("System.gc后");
System.out.println(userSoftRef.get());
}
//[id=1, name=songhk]
//System.gc后
//null
}
// 声明强引用
Object obj = new Object();
// 声明引用队列
ReferenceQueue phantomQueue = new ReferenceQueue();
// 声明虚引用(还需要传入引用队列)
PhantomReference
public class PhantomReferenceTest {
public static PhantomReferenceTest obj;//当前类对象的声明
static ReferenceQueue phantomQueue = null;//引用队列
public static class CheckRefQueue extends Thread {
@Override
public void run() {
while (true) {
if (phantomQueue != null) {
PhantomReference objt = null;
try {
objt = (PhantomReference) phantomQueue.remove();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (objt != null) {
System.out.println("追踪垃圾回收过程:从队列当中取出了objt,证明之前的PhantomReferenceTest实例被GC了");
}
}
}
}
}
@Override
protected void finalize() throws Throwable { //finalize()方法只能被调用一次!
super.finalize();
System.out.println("调用当前类的finalize()方法");
obj = this;
}
public static void main(String[] args) {
Thread t = new CheckRefQueue();
t.setDaemon(true);//设置为守护线程:当程序中没有非守护线程时,守护线程也就执行结束。
t.start();
phantomQueue = new ReferenceQueue();
obj = new PhantomReferenceTest();
//构造了 PhantomReferenceTest 对象的虚引用,并指定了引用队列
PhantomReference phantomRef = new PhantomReference(obj, phantomQueue);
try {
//不可获取虚引用中的对象
System.out.println(phantomRef.get());
//将强引用去除
obj = null;
//第一次进行GC,由于对象在finalize()重写了可复活,GC无法回收该对象
System.out.println("第 1 次 gc");
System.gc();
Thread.sleep(1000);
if (obj == null) {
System.out.println("obj 是 null");
} else {
System.out.println("obj 可用");
}
System.out.println("第 2 次 gc");
obj = null;
System.gc(); //一旦将obj对象回收,就会将此虚引用存放到引用队列中。finalize()只会执行一次,不会再复活了
Thread.sleep(1000);
if (obj == null) {
System.out.println("obj 是 null");
} else {
System.out.println("obj 可用");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
null
第 1 次 gc
调用当前类的finalize()方法
obj 可用
第 2 次 gc
追踪垃圾回收过程:从队列当中取出了objt,证明之前的PhantomReferenceTest实例被GC了
obj 是 null
虚引用必须和引用队列一起使用
虚引用不可以通过get()获取强引用对象
当强引用对象不可触及状态后,触发虚引用