JAVA

Posted 2021-06-05 杨大德

实现单例模式的八种方式
第一种：
public class Mg01 {
private static final Mg01 INSTANCE = new Mg01();

private Mg01() {
}

public static Mg01 getInstance() {
    return INSTANCE;
}

}
简单、安全，缺点不管使用与否加载类时就会实例化 如Class.forName()
第二种：与第一种相同
public class Mg02 {
private static final Mg02 INSTANCE;

static {
    INSTANCE = new Mg02();
}

private Mg02() {
}

public static Mg02 getInstance() {
    return INSTANCE;
}

}
第三种：线程不安全、不推荐使用
public class Mg03 {
private static Mg03 INSTANCE;

private Mg03() {
}

public static Mg03 getInstance() {
    if (INSTANCE == null) {
        INSTANCE = new Mg03();
    }
    return INSTANCE;
}

}
第四种：方法加锁 -- 效率问题
public class Mg04 {
private static Mg04 INSTANCE;

private Mg04() {
}

public synchronized static Mg04 getInstance() {
    if (INSTANCE == null) {
        INSTANCE = new Mg04();
    }
    return INSTANCE;
}

}
第五种：同步代码块。不安全
public class Mg05 {
private static Mg05 INSTANCE;

private Mg05() {
}

public synchronized static Mg05 getInstance() {
    if (INSTANCE == null) {
        synchronized (Mg05.class){
            INSTANCE = new Mg05();
        }            
    }
    return INSTANCE;
}

}
第六种：双重检查 复杂 添加volatile JIT优化时指令重排会在没有初始化的时候返回instance
public class Mg06 {
private static volatile Mg06 INSTANCE;

private Mg06() {
}

public synchronized static Mg06 getInstance() {
    if (INSTANCE == null) {
        synchronized (Mg06.class){
            if (INSTANCE == null) {
                INSTANCE = new Mg06();
            }
        }
    }
    return INSTANCE;
}

}
第七种：静态内部类，懒加载的完美实现方式
public class Mg07 {

private Mg07() {
}

private static class Singleton{
    private static Mg07 INSTANCE = new Mg07();
}
public static Mg07 getInstance() {
    return Singleton.INSTANCE;
}

}
第八种：枚举单例 完美解决并且防止反序列化