JVM学习之四-----对象内存分配与回收

对象内存分配的流程图如下：

对象栈上分配
我们通过jvm内存分配可以知道Java中的对象都是在堆上进行分配，当对象没有被引用的时候，需要依靠GC进行回收内存，如果对象数量较多的时候，会给GC带来较大的压力，也间接影响了性能。为了减少临时对象在堆内分配的数量，jvm通过逃逸分析确定该对象不会被外部访问。如果不会逃逸可以将该对象在栈上分配内存，这样对象所占用的内存空间可以随栈而销毁，减轻了垃圾回收的压力。
对象逃逸：就是分析对象动态作用域，当一个对象在方法中被定义后，它可能被外部方法所引用，列如作为调用参数传递到其他方法中。

public User test1() {
   User user = new User();
   user.setId(1);
   user.setName("zhuge");
   //TODO 保存到数据库
   return user;
}

public void test2() {
   User user = new User();
   user.setId(1);
   user.setName("zhuge");
   //TODO 保存到数据库
}

test1()中的user对象被返回了，这个对象的作用域范围不确定，test2()方法中的user对象我们可以确定当方法结束这个对象就可以认为是无效对象，对于这样的对象我们可以将其分配在栈内存里，让其在方法结束时跟随栈内存一起被回收掉。
JVM对于这种情况可以通过开启逃逸分析参数(-XX:+DoEscapeAnalysis)来优化对象内存分配位置，使其通过 标量替换 优先分配在栈上(栈上分配)，jdk1.7之后默认开启，如果要关闭使用参数(-XX:-DoEscapeAnalysis)。
标量替换:通过逃逸分析确定该对象不会被外部访问，并且对象可以被进一步分解时，JVM不会创建该对象，而是将该对象，而是将该对象成员变量分解若干被这个方法使用的成员变量所代替，这些代替的成员变量在栈帧或寄存器上分配空间，这样就不会因为没有一大块连续空间导致对象内存不够分配。

/**
 * 栈上分配，标量替换
 * 代码调用了1亿次alloc()，如果是分配到堆上，大概需要1GB以上堆空间，如果堆空间小于该值，必然会触发GC。
 * 
 * 使用如下参数不会发生GC
 * -Xmx15m -Xms15m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:+EliminateAllocations
 * 使用如下参数都会发生大量GC
 * -Xmx15m -Xms15m -XX:-DoEscapeAnalysis -XX:+PrintGC -XX:+EliminateAllocations
 * -Xmx15m -Xms15m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-EliminateAllocations
 */
public class AllotOnStack {

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            alloc();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    private static void alloc() {
        User user = new User();
        user.setId(1);
        user.setName("zhuge");
    }
}

栈上分配依赖于逃逸分析和标量替换
对象在Eden去分配
Minor GC和Full GC的区别：
Minor GC/Young GC : 指发生新生代的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。
Full GC: 一般会回收老年代，年轻代，方法区的垃圾，Full GC的速度一般会比Minor GC的慢10倍以上。
Eden与Survivor区默认8:1：1

大量的对象被分配在Eden去，Eden区满了后会触发minor gc， 可能会有99%以上的对象成为垃圾被回收掉，剩余存活对象会被挪到survivor区，下一次eden区满了后会触发minor gc，把eden区和survivor区垃圾对象回收，把剩余存活的对象一次性挪动到另外一块为空的survivor区。

大对象直接进入老年代
大对象就是需要大量连续内存空间的对象(比如:字符串、数组)。jvm参数XX:PretenureSizeThreshold 可以设置大对象的大小，如果对象超过设置大小会直接进入老年代，不会进入年轻代，这个参数只在 Serial 和ParNew两个收集器下有效。
比如设置JVM参数：-XX:PretenureSizeThreshold=1000000 (单位是字节) -XX:+UseSerialGC ，再执行下上面的第一个程序会发现大对象直接进了老年代
为什么要这样呢？
为了避免为大对象分配内存时的复制操作而降低效率。

长期存活的对象将进入老年代
既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须要能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了做到这一点，虚拟机给每个对象一个对象年龄计数器。如果对象在Eden出生并经过第一次Minor GC后仍能存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设为1.对象在Survivor中每熬过一次MinorGC，年龄就增加1岁。当它的年龄增加到一定程度(默认是15岁)，就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数-XX:MaxTenuringThreshold 来设置。

对象动态年龄判断
当前放对象的Survivor区域里，一批对象的总大小大于这块Survivor区域内存大小的50%，那么此时大于等于这批对象年龄最大值的对象，就可以直接进入老年代。

老年代空间分配担保机制
年轻代每次minor gc之前JVM都会计算下老年代剩余可用空间
如果这个可用空间小于年轻代里现有的所有对象大小之和(包括垃圾对象)
就会看一个“-XX:-HandlePromotionFailure”(jdk1.8默认就设置了)的参数是否设置了
如果有这个参数，就会看看老年代的可用内存大小，是否大于之前每一次minor gc后进入老年代的对象的平均大小。
如果上一步结果是小于或者之前说的参数没有设置，那么就会触发一次Full gc，对老年代和年轻代一起回收一次垃圾，如果回收完还是没有足够空间存放新的对象就会发生"OOM"
当然，如果minor gc之后剩余存活的需要挪动到老年代的对象大小还是大于老年代可用空间，那么也会触发full gc，full gc完之后如果还是没有空间放minor gc之后的存活对象，则也会发生“OOM”

对象内存回收
堆中几乎放着所有的对象实例，对堆垃圾回收前的第一步就是要判断哪些对象已经死亡。
一：引用计数器法
给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加1；当引用失效时，就减1；
任何时候计数器为0的对象就是不在被使用的。
这个存在的主要问题是：难以解决相互循环引用的问题。
如下面代码所示：除了对象objA 和 objB 相互引用着对方之外，这两个对象之间再无任何引用。但是他们因为互相引用对方，导致它们的引用计数器都不为0，于是引用计数算法无法通知 GC 回收器回收他们。

public class ReferenceCountingGc {
   Object instance = null;

   public static void main(String[] args) {
      ReferenceCountingGc objA = new ReferenceCountingGc();
      ReferenceCountingGc objB = new ReferenceCountingGc();
      objA.instance = objB;
      objB.instance = objA;
      objA = null;
      objB = null;
   }
}

二：可达性算法
将“GC Roots” 对象作为起点，将这些节点开始向下搜索引用的对象，找到的对象都标记为非垃圾对象时候，其余未标记的都是垃圾对象。
GC Roots 跟节点：线程栈的本地变量、静态变量、本地方法栈等变量等。

Java的引用类型一般分为：强引用，软引用，弱引用，虚引用
强引用：普通的变量引用

public static User user = new User();

软引用:将对象用SoftReference软引用类型的对象包裹，正常情况不会被回收，但是将GC做完后发现释放不出空间存放新的对象，则会把这些软引用的对象回收掉。软引用可用来实现内存敏感的高速缓存。

public static SoftReference<User> user = new SoftReference<User>(new User());