8种单例模式的实现

Posted 2021-07-17 阿昌喜欢吃黄桃

单例模式8种写法

一、单例模式的作用

1、为什么需要单例模式？

- 节省内存和计算、
- 保证结果正确、
-  方便管理

2、使用场景

---

3、 8种写法

• 饿汉式（静态常量）—可用

*//饿汉式（静态常量） ---可用
public class Singleton1 {
    private final static Singleton1 INSTANCE = new Singleton1();

    private Singleton1(){}

    public static Singleton1 getInstance(){
        return INSTANCE;
    }
}

• 饿汉式（静态代码块） —可用

//饿汉式（静态代码块） ---可用
public class Singleton2 {
    private final static Singleton2 INSTANCE;
    static {
        INSTANCE = new Singleton2();
    }

    private Singleton2(){}

    public static Singleton2 getInstance(){
        return INSTANCE;
    }
}

• 懒汉试（线程不安全）—不可用

//懒汉试（线程不安全）---不可用
public class Singleton3 {

    private static Singleton3 Instance;

    private Singleton3(){}

    public static Singleton3 getInstance(){
        if (Instance == null){
            Instance = new Singleton3();
        }
        return Instance;
    }
}

• 懒汉试（线程安全，同步方法）—不推荐使用
  • 效率太低了！！！

//懒汉试（线程安全）---不推荐
public class Singleton4 {

    private static Singleton4 Instance;

    private Singleton4(){}

    public synchronized static Singleton4 getInstance(){
        if (Instance == null){
            Instance = new Singleton4();
        }
        return Instance;
    }
}

• 懒汉试（线程不安全，同步代码块）—不可用

//懒汉试（线程不安全，同步代码块）---不可用
public class Singleton5 {

    private static Singleton5 Instance;

    private Singleton5(){}

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

• 双重检查—推荐面试时使用

//双重检查---推荐面试时使用
public class Singleton6 {

    private volatile static Singleton6 Instance;

    private Singleton6(){}

    public static Singleton6 getInstance(){
        if (Instance == null){
            synchronized (Singleton6.class){
                //再做一次检查
                if (Instance == null){
                Instance = new Singleton6();
                }
            }
        }
        return Instance;
    }
}

• 静态内部类 — 推荐使用

//静态内部类 --- 推荐使用
public class Singleton7 {

    private Singleton7(){}

    private static class SingletonInstance{
        //JVM会保证构造方法的线程安全问题
        private static final Singleton7 INSTANCE = new Singleton7();
    }

    public static Singleton7 getInstance(){
        return SingletonInstance.INSTANCE;
    }

}

• 枚举 — 生产实践推荐使用

//枚举 --- 生产实践推荐使用
public enum Singleton8 {
    INSTANCE;

    //方法
    public void whatever(){ }
}

---

4、以上写法的对比

5、那种单例的实现方案最好？

枚举的实现方式最好

---

6、各个写法的使用场合