Java概念

四种引用类型

强引用

通过变量名指向对象或值的内存地址，可以直接访问或者操作对象。
JVM宁愿抛出内存溢出异常，也不会回收被强引用指向的对象
FinalReference不等同与强应用

软引用（SoftReference）

软引用是除了强引用之外最强的应用类型
在GC发生的时候，会对软引用进行回收

弱引用（WeakReference）

当一个仅仅持有弱引用的对象被垃圾回收器扫描到时，无论此时的内存如何，都会将这个对象回收
弱引用可以和一个引用队列联合使用，如果弱引用所引用的对象被垃圾回收器回收，虚拟机会把这个弱引用加到与之关联的引用队列中

虚引用（PhantomReference）

虚引用必须和引用队列一起使用，主要用来跟踪对象被垃圾回收器回收的活动。
当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象之前，将虚引用加入到关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收机制回收。

对象的生命周期

创建阶段(Created)

创建阶段是一个对象的创建过程：

加载class文件，静态变量初始化
分配堆空间
超类成员变量、构造函数初始化
调用超类构造方法
本类成员变量、构造函数初始化
本类构造方法调用

应用阶段(In Use)

对象至少被一个强引用持有着

不可见阶段(Invisible)

对象的引用仍然存在,但是程序本身不持有该对象的任何强引用

程序执行完成一个方法后，方法中的局部变量都处于不可见的一种状态

不可达阶段(Unreachable)

一个对象不被任何强引用持有

User u = new User(); // Created and In Use
u = null; // Unreachable

收集阶段(Collected)

当垃圾回收器发现对象已经处于Unreachable状态并且已经对该对象的内存空间重新分配做好准备时，则对象进入了Collected阶段，如果该对象已经重写了finalize方法，则会去执行该方法。

为什么最好不要重写finalize方法？

1、会影响JVM的对象分配与回收速度

JVM在垃圾回收器上注册对象 --> 执行finalize方法消耗cpu --> 方法结束重新执行回收操作 --> 至少2次GC

2、可能造成该对象的再次复活

如果在finalize方法中，有强引用持有了这个对象，会导致这个对象转变为In Use状态，破坏了生命周期进程

终结阶段(Finalized)

当对象执行完finalize方法后任然处于Unreachable状态，则对象进入Finalized状态。等待垃圾回收器回收。

对象空间重分配阶段(De-allocated)

垃圾回收器对该对象占用的内存进行回收或者再分配，则该对象就彻底消失。

Java中的设计模式

创建型模式（共五种）

工厂方法模式
抽象工厂模式
单例模式
建造者模式
原型模式

结构型模式（共七种）

适配器模式
装饰器模式
代理模式
外观模式
桥接模式
组合模式
享元模式

行为型模式（共十一种）

策略模式
模板方法模式
观察者模式
迭代子模式
责任链模式
命令模式
备忘录模式
状态模式
访问者模式
中介者模式
解释器模式

另外的：并发型模式和线程池模式

GC发生的时机

YGC发生的时机

eden区空间不足

FGC发生的时机

老年代空间不足(大对象存储空间超过阈值、年龄超过15的对象和大于老年代剩余空间、老年代连续空间不足 ...)
元空间达到阈值
System.gc 会建议JVM调用Full GC

Java对象逃逸

jdk1.7开始会默认开启逃逸分析：-XX:+DoEscapeAnalysis，如需关闭需要指定：-XX:-DoEscapeAnalysis

什么是对象逃逸？
一个对象的作用范围逃出了当前方法（方法逃逸）或者当前线程（线程逃逸）

// StringBuffer 对象逃逸
public static StringBuffer craeteStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb;
}
// StringBuffer 对象没有逃逸
public static String createStringBuffer(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

开启逃逸分析的好处：

锁消除：如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步

public void f() {
    Object o = new Object();
    synchronized(o) {
        System.out.println(o);
    }
}

优化为：

public void f() {
    Object o = new Object();
    System.out.println(o);
}

标量替换：分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在CPU寄存器中

public static void main(String[] args) {
   alloc();
}

private static void alloc() {
   Point point = new Point（1,2）;
   System.out.println("point.x="+point.x+"; point.y="+point.y);
}
class Point{
    private int x;
    private int y;
}

优化后：

private static void alloc() {
   int x = 1;
   int y = 2;
   System.out.println("point.x="+x+"; point.y="+y);
}

栈上分配：在Java虚拟机中，对象是在Java堆中分配内存的，这是一个普遍的常识。但是，有一种特殊情况，那就是如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话，那么就可能被优化成栈上分配。这样就无需在堆上分配内存，也无须进行垃圾回收了

public static void main(String[] args) {
    long a1 = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        alloc();
    }
    // 查看执行时间
    long a2 = System.currentTimeMillis();
    System.out.println("cost " + (a2 - a1) + " ms");
    // 为了方便查看堆内存中对象个数，线程sleep
    try {
        Thread.sleep(100000);
    } catch (InterruptedException e1) {
        e1.printStackTrace();
    }
}
private static void alloc() {
    User user = new User();
}
static class User {
}