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 {
}