飞天班第7节：深入JVM系列（下）

Person person = null; // 不再被引用的对象

public class GCRoots{
    // private byte[] array = new byte[100*1024*1024]; // 开辟内存空间！在堆里
    // private static GCRoots2 t2; // GC root;
    // private static final GCRoots3 t3 = new GCRoots3(); // GC root;
    
    // 引用远远不止于此，强引用，软引用，弱引用，虚引用！ 四个类的使用！
    public static void m1(){
        GCRoots g1 = new GCRoots(); //GC root  根对象
        System.gc();
    }
    
    public static void main(String[] args){
        m1();
    }
}

// 方法不断递归调用自己，栈溢出
public static void main(String[] args) {
    a();
}

public static void a(){
    a();
}

/*
 * -Xmx8m -Xms8m -XX:+PrintGCDetails
 *
 * 分析GC日志：[GC (System.gc()) [PSYoungGen: 1344K->496K(2048K)] 1344K->536K(7680K), 0.0008573 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
 
 * 1、GC 类型  GC：普通的GC，Full GC ：重GC
 * 2、1344K 执行 GC之前的大小
 * 3、496K  执行 GC之后的大小
 * 4、(2048K) young 的total大小
 * 5、0.0012643 secs 清理的时间
 * 6、user 总计GC所占用CPU的时间   sys OS调用等待的时间   real 应用暂停的时间
 *
 * GC ：串行执行 STW（Stop The World理论，暂停整个世界，就是我在GC的时候，程序是不能运行的，直到我收完垃圾，程序才恢复运行）  
 并行执行   G1
*/
public class Demo02 {
    public static void main(String[] args) {
        System.gc(); // 手动唤醒GC（），但实际上它不会马上GC，它会等待cpu的调用
        String str = "ilovecoding";
        while (true){
            str += str + new Random().nextInt(999999999)
                    + new Random().nextInt(999999999);
        }
        // 最终出现问题：java.lang.OutOfMemoryError: Java heap space
    }
}

// -Xms10m -Xmx10m -XX:MaxDirectMemorySize=5m -XX:+PrintGCDetails
public class OomDemo {
    public static void main(String[] args) throws Throwable {
        int i = 0;
        List<String> list = new ArrayList<String>();

        try {
            while (true){
                list.add(String.valueOf(++i).intern());
            }
        } catch (Throwable e) {  // 会抛出Error，Exception无法捕获，要使用父类 Throwable
            System.out.println("i=>"+i);
            e.printStackTrace();
            throw e;
        }
    }
}

// -Xms10m -Xmx10m -XX:MaxDirectMemorySize=5m -XX:+PrintGCDetails
public class OomDemo {
  public static void main(String[] args) throws Throwable {
    System.out.println("配置的MaxDirectMemorySize"
                       +VM.maxDirectMemory()/(double)1024/1024+"MB");

    TimeUnit.SECONDS.sleep(2);
    // 故意破坏！我们只设置了本地内存最大5m,创建一个6m大的byteBuffer，那它就溢出了
    // ByteBuffer.allocate(); 分配JVM的堆内存，属于GC管辖
    // ByteBuffer.allocateDirect() ; // 分配本地OS内存，不属于GC管辖
    ByteBuffer byteBuffer = ByteBuffer.allocateDirect(6 * 1024 * 1024);
    // java.lang.OutOfMemoryError: Direct buffer memory
  }
}

import java.lang.reflect.Field;
import java.nio.ByteBuffer;

public class MaxDirectMemorySize {
  public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
    System.out.println("maxMemoryValue:"+sun.misc.VM.maxDirectMemory()); 

    System.out.println("================================");
    ByteBuffer buffer=ByteBuffer.allocateDirect(0);
    Class<?> c = Class.forName("java.nio.Bits");  
    Field maxMemory = c.getDeclaredField("maxMemory");  
    maxMemory.setAccessible(true);  
    synchronized (c) {  
      Long maxMemoryValue = (Long)maxMemory.get(null);  
      System.out.println("maxMemoryValue:"+maxMemoryValue);  
    }  
  }
}

public class TDemo {
    public static void main(String[] args) {
      // 不断的创建线程，不用轻易在服务器上测试，会把内存
        for (int i = 1; ; i++) {
            System.out.println("i=>"+i);
            new Thread(()->{
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },""+i).start();
        }
    }
}

import org.springframework.cglib.proxy.Enhancer;

// -XX:MetaspaceSize=10m -XX:MaxMetaspaceSize=10m
public class OomDemo {
    
    static class OOMTest{}

    public static void main(String[] args) throws Throwable {
        int i = 0; // 模拟计数器

        try {
            while (true){
                i++;
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(OOMTest.class);
                enhancer.setUseCache(false);
                enhancer.setCallback(new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        return method.invoke(o,args);
                    }
                });
                enhancer.create();
            }
        } catch (Throwable e) {
            System.out.println("i=>"+i);
            e.printStackTrace();
        }
        
    }
}

//-Xms5m -Xmx5m -XX:+PrintGCDetails
public class Demo01  {
	public static void main(String[] args) {
		Object o1 = new Object(); // 这养定义的默认就是强引用
		Object o2 = o1;     // 真正的Object 对象信息存在堆中，o1和o2就是引用变量，存在JVM栈中
		o1=null;

		try {
			byte[] bytes = new byte[10 * 1024 * 1024];
		}catch (Throwable e){
			e.printStackTrace();
		}
		finally {
			System.out.println(o1); // null
			System.out.println(o2); // java.lang.Object@6ff3c5b5
		}
	}
}

public class Demo02 {
	public static void main(String[] args) {
		Object o1 = new Object(); // 这养定义的默认就是强引用
		SoftReference<Object> o2 = new SoftReference<>(o1);
		System.out.println(o1);
		System.out.println(o2.get()); // 得到引用的值

		o1=null;

		System.gc();

		System.out.println(o1); // null
		System.out.println(o2.get()); // java.lang.Object@6ff3c5b5
	}
}

//-Xms5m -Xmx5m -XX:+PrintGCDetails
public class Demo02 {
	public static void main(String[] args) {
		Object o1 = new Object(); // 这养定义的默认就是强引用
		SoftReference<Object> o2 = new SoftReference<>(o1);
		System.out.println(o1);
		System.out.println(o2.get()); // 得到引用的值

		o1=null;

		try {
			byte[] bytes = new byte[10 * 1024 * 1024];
		}catch (Throwable e){
			e.printStackTrace();
		}
		finally {
			System.out.println(o1); // null
			System.out.println(o2); // java.lang.Object@6ff3c5b5
		}
	}
}

public class Demo03 {
	public static void main(String[] args) {
		Object o1 = new Object(); // 这养定义的默认就是强引用
		WeakReference<Object> o2 = new WeakReference<>(o1);
		System.out.println(o1);
		System.out.println(o2.get()); // 得到引用的值

		o1=null;
		System.gc();
		System.out.println(o1);
		System.out.println(o2.get()); // 得到引用的值
	}
}

HashMap<String,SoftReference<Pic>> stringSoftReferenceHashMap = new HashMap<>();

public class Demo04 {
	public static void main(String[] args) throws InterruptedException {
		Object o1 = new Object();  // 这样定义的默认就是强引用
		// 虚引用 PhantomReference 需要结合队列使用
		ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
		PhantomReference<Object> phantomReference = new PhantomReference<>(o1,referenceQueue);

		System.out.println(o1); // 
		System.out.println(phantomReference.get()); // null
		System.out.println(referenceQueue.poll()); // null
    o1=null;
		System.gc();

		TimeUnit.SECONDS.sleep(1000);

		System.out.println(o1);  // null
		System.out.println(phantomReference.get()); // null
    // 通知机制！ 好比我们常用的消息队列，消息消费了，ACK
    // 通过队列检测哪些对象被清理了，可以处理一些善后动作
		System.out.println(referenceQueue.poll());
	}
}