【深入理解Java原理】垃圾回收原理-CFANZ编程社区

CMS垃圾回收器 Concurent Marked Sweep

并行的标记垃圾回收器

获取最短停顿的回收器，标记清除算法实现

缺点是：

1.对cpu资源敏感

2.无法处理浮动垃圾

3.有大量碎片产生

CMS 垃圾回收的六个步骤：

1. 初始标记

初始标记会触发 stop the world ，从垃圾回收的根对象开始查找，这个过程会暂停整个JVM，但是很快结束

2.并行标记

并发标记进行和用户线程同时执行。用户不会感觉卡顿

3.并发预清理

并发预清理阶段是并行的，标记新生代进入老年代的对象。

4.重新标记

扫描堆中剩余的对象，然后重新从根对象进行扫描会 stop the word

5.并发清理

清理垃圾对象。和用户线程并发执行

6.并发重置

重置CMS数据结构，等待下一次垃圾回收

流程图如下：

【深入理解Java原理】垃圾回收原理_java

什么时候触发GC？

1. 执行 system.gc()的时候

2.老年代空间不足，一次Full GC 之后，然后不足会触发 java.outofmemoryError:java heap space

3.永久代空间不足永生代或者永久代java.outofMemory PerGen Space

4. minor之后 survior放不下，放入老年代，老年代也放不下，触发FullGC, 或者新生代有对象放入老年代，老年代放不下，触发FullGC

5.新生代晋升为老年代时候，老年代剩余空间低于新生代晋升为老年代的速率，会触发老年代回收

6. new 一个大对象，新生代放不下，直接到老年代，空间不够，触发FullGC

怎么避免频繁GC

1. 不要频繁的new 对象

2. 不要显示的调研system.gc()

3. 不要用String+ 使用StringBuilder

4.不要使用Long Integer 尽量使用基本类型

5.少用静态变量不会回收

6.可以使用null 进行回收

什么是内存泄漏？如何避免？

内存泄露是，这个对象从Root可以找到，但是这个对象是无用的，永远不会被回收，这个就存在内存泄漏

Vector v=new Vector(10);
for (int i=1;i<100; i++)
{
    Object o=new Object();
    v.add(o);
    o=null; 
}

为什么JDK1.8之后要移除Permgen Space 替换成了MetaSpace ?

permGen存放的数据内容:类的静态常量，字符串，类的元信息

MetaSpace存放的数据：和PermGen数据类型类似，描述类元数据 class已经被移除

区别是啥？

PermGen存放的是在JVM中的，如果load很多Class 的话，会导致OOM :PermGen error问题

但是MetaSpace是存放在本地内存空间的，是依赖本地内存空间的大小。

为啥要替换成MetaSpace？

1. Class的大小无法控制，无法设定permGen 的大小，太小了，容易溢出，太大了，JVM内存浪费，也容易导致堆内存可用空间少，导致老年代溢出

2.字符串存放在永久代，容易导致内存溢出

3. 提高了FullGC性能，Metadata 到Metadatapointer之间不用扫描

会有个metaspace threshold, 可能存在的问题是，存在内存泄漏，不断的扩展metaspace 会导致机器内存不足, 所以也需要监控

什么是内存溢出？

程序申请内存的时候，内存没有空间分配了。

什么是守护线程？和非守护线程（用户线程）？区别是啥？

守护线程的作用是为用户线程提供服务便利的，垃圾回收器就是一个守护线程？

非守护线程线程全部结束，守护线程跟者结束。

测试用例：

import java.util.concurrent.TimeUnit;  

public class DaemonThreadTest  {  
    public static void main(String[] args)  
    {  
        Thread mainThread = new Thread(new Runnable(){  
            @Override 
            public void run()  
            {  
                Thread childThread = new Thread(new ClildThread());  
                childThread.setDaemon(true);  
                childThread.start();  
                System.out.println("I'm main thread...");  
            }  
        });  
        mainThread.start();  
    }  
}  

class ClildThread implements Runnable  {  
    @Override 
    public void run()  
    {  
        while(true)  
        {  
            System.out.println("I'm child thread..");  
            try 
            {  
                TimeUnit.MILLISECONDS.sleep(1000);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }

将主线程停止工作，守护线程依然执行，可通过如下设置

childThread.setDaemon(false);

守护线程是当非守护线程，全部结束，则程序结束

import java.util.concurrent.TimeUnit;  

public class DaemonThreadTest  {  
    public static void main(String[] args)  
    {  
        Thread mainThread = new Thread(new Runnable(){  
            @Override 
            public void run()  
            {  
                Thread childThread = new Thread(new ClildThread());  
                childThread.setDaemon(true);  
                childThread.start();  
                System.out.println("I'm main thread...");  
            }  
        });  
        mainThread.start();  


        Thread otherThread = new Thread(new Runnable(){  
            @Override 
            public void run()  
            {  
                while(true)  
                {  
                    System.out.println("I'm other user thread...");  
                    try 
                    {  
                        TimeUnit.MILLISECONDS.sleep(1000);  
                    }  
                    catch (InterruptedException e)  
                    {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        });  
        otherThread.start();  

    }  
}  

class ClildThread implements Runnable  {  
    @Override 
    public void run()  
    {  
        while(true)  
        {  
            System.out.println("I'm child thread..");  
            try 
            {  
                TimeUnit.MILLISECONDS.sleep(1000);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
        }  
    }  
}