3.深刻jvm内核-原理、诊断与优化-4. GC算法和种类

时间 2020-01-17

标签深刻 jvm 内核原理诊断优化算法种类栏目 Java 繁體版

原文原文链接

1、GC算法和种类算法

GC的概念ide

GC算法
 引用计数法
 标记清除
 标记压缩
 复制算法
 可触及性
 Stop-The-World
 GC的对象是堆空间和永久区

引用计数法优化

老牌垃圾回收算法
 经过引用计算来回收垃圾
 使用者
 COM
 ActionScript3
 Python

标记-清除this

标记-清除算法是现代垃圾回收算法的思想基础。
 标记-清除算法将垃圾回收分为两个阶段：标记阶段和清除阶段。
 一种可行的实现是，在标记阶段，首先经过根节点，标记全部从根节点开始的可达对象。所以，未被标记的对象就是未被引用的垃圾对象。
 而后，在清除阶段，清除全部未被标记的对象。

标记-压缩线程

标记-压缩算法适合用于存活对象较多的场合，如老年代。
 它在标记-清除算法的基础上作了一些优化。和标记-清除算法同样，标记-压缩算法也首先须要从根节点开始，对全部可达对象作一次标记。
 但以后，它并不简单的清理未标记的对象，而是将全部的存活对象压缩到内存的一端。以后，清理边界外全部的空间。

复制算法3d

与标记-清除算法相比，复制算法是一种相对高效的回收方法
 不适用于存活对象较多的场合 如老年代
 将原有的内存空间分为两块，每次只使用其中一块，在垃圾回收时，将正在使用的内存中的存活对象复制到未使用的内存块中，以后，清除正在使用的内存块中的全部对象，交换两个内存的角色，完成垃圾回收

分代思想code

依据对象的存活周期进行分类，短命对象归为新生代，长命对象归为老年代。
 根据不一样代的特色，选取合适的收集算法
 少许对象存活，适合复制算法
 大量对象存活，适合标记清理或者标记压缩

gc算法总结对象

可触及性blog

可触及的
 从根节点能够触及到这个对象
 可复活的
 一旦全部引用被释放，就是可复活状态
 由于在finalize()中可能复活该对象
 不可触及的
 在finalize()后，可能会进入不可触及状态
 不可触及的对象不可能复活
 能够回收

public class CanReliveObj {
		public static CanReliveObj obj;
		@Override
		protected void finalize() throws Throwable {
			super.finalize();
			System.out.println("CanReliveObj finalize called");
			obj=this;
		}
		@Override
		public String toString(){
			return "I am CanReliveObj";
		}

public static void main(String[] args) throws
		 InterruptedException{
	obj=new CanReliveObj();
	obj=null;   //可复活
	System.gc();
	Thread.sleep(1000);
	if(obj==null){
		System.out.println("obj 是 null");
	}else{
		System.out.println("obj 可用");
	}
	System.out.println("第二次gc");
	obj=null;    //不可复活
	System.gc();
	Thread.sleep(1000);
	if(obj==null){
	System.out.println("obj 是 null");
	}else{
	System.out.println("obj 可用");
	}
	}
	}

经验：避免使用finalize()，操做不慎可能致使错误。
 优先级低，什么时候被调用， 不肯定
 什么时候发生GC不肯定
 可使用try-catch-finally来替代它

根ip

栈中引用的对象
 方法区中静态成员或者常量引用的对象（全局对象）
 JNI方法栈中引用对象

Stop-The-World

Java中一种全局暂停的现象
 全局停顿，全部Java代码中止，native代码能够执行，但不能和JVM交互
 多半因为GC引发
 Dump线程
 死锁检查
 堆Dump

每秒打印10条(这个是jdk6的，jdk8的gc回收停顿没有这么长，知道原理后续在分析)

public static class PrintThread extends Thread{
		public final long starttime=System.currentTimeMillis();
		@Override
		public void run(){
			try{
				while(true){
					long t=System.currentTimeMillis()-starttime;
					System.out.println("time:"+t);
					Thread.sleep(100);
				}
			}catch(Exception e){

			}
		}
	}

public class MyThread extends Thread{
		HashMap<Long,byte[]> map=new HashMap<Long,byte[]>();
		@Override
		public void run(){
			try{
				while(true){
					if(map.size()*512/1024/1024>=450){
						System.out.println(“=====准备清理=====:"+map.size());
						map.clear();
					}

					for(int i=0;i<1024;i++){
						map.put(System.nanoTime(), new byte[512]);
					}
					Thread.sleep(1);
				}
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}