设计模式 | 单例模式的7种写法

单例设计模式

单例模式(Singleton Pattern)是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

饿汉式

类加载就会导致该单例对象被创建。存在内存浪费。

1️⃣静态变量方式

public class Demo1 {
    public static void main(String[] args) {
        //创建Singleton的对象
        Singleton1 singleton1 = Singleton1.getInstance();
        Singleton1 singleton2 = Singleton1.getInstance();
        //判断两个对象是否是同一个对象
        System.out.println(singleton1 == singleton2); //输出true
    }

}

class Singleton1{
    /**
     * 1.私有构造方法
     */
    private Singleton1(){}
    //2.在本类中创建本类对象
    private static Singleton1 instance =  new Singleton1();
    //3.提供一个公共的访问方式,因为不能创建对象就不能使用其中的方法，所以使用静态方法
    public static Singleton1 getInstance(){
        return instance;
    }

}

2️⃣静态代码块的方式

/**
 * 静态代码块方式
 */
class Singleton2{
    //1.私有构造方法
    private Singleton2(){};
    //2.声明Singleton2类型的变量
    private static Singleton2 instance; //初始值为null。。。
    //3.在静态代码块中赋值
    static{
        instance = new Singleton2();
    }
    //4.对外提供一个方法
    public static Singleton2 getInstance(){
        return instance;
    }
}

3️⃣枚举方式

枚举实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者冲分的利用了枚举的这个特性来实现单例模式。

public class Test {
    public static void main(String[] args) {
        EnumSingleton instance = EnumSingleton.INSTANCE;
        EnumSingleton instance1 = EnumSingleton.INSTANCE;

        System.out.println(instance == instance1);
    }

}


/**
 * 枚举方式
 */
public enum EnumSingleton {
    INSTANCE;
}

不考虑空间的情况下，首选枚举。

懒汉式

1️⃣线程不安全的方式

package com.wangze.pattern.singleton;

/**
 * @author 结构化思维wz
 */

public class Demo2 {
    public static void main(String[] args) {
        System.out.println("懒汉式创建=====线程不安全====");
        //单线程模式
        Singleton3 singleton3 = Singleton3.getInstance();
        Singleton3 singleton4 = Singleton3.getInstance();
        System.out.println(singleton3 == singleton4);
    }

}
class Singleton3{
    //1.私有构造方法
    private Singleton3(){}
    //2.声明Singleton类型的变量
    private static Singleton3 intance;
    //3.对外提供访问方式
    public static Singleton3 getInstance(){
        if (intance == null){
            intance = new Singleton3();
        }
        return intance;
    }
}

2️⃣线程安全的情况

/**
 * 线程安全的情况
 */
class Singleton4{
    //1.私有构造方法
    private Singleton4(){}
    //2.声明Singleton类型的变量
    private static Singleton4 intance;
    //3.对外提供访问方式
    public static synchronized Singleton4 getInstance(){
        if (intance == null){
            intance = new Singleton4();
        }
        return intance;
    }
}

这种方式虽然线程安全，但是会使性能下降。

3️⃣ 双重检查锁

/**
 * 双重检查锁方式(把读写分离，读不用锁)
 */
class Singleton{
    //1.私有构造方法
    private Singleton(){}
    
    //声明Singleton类型的变量
    private static Singleton instance;
    
    //对外提供公共的访问方式
    public static Singleton getInstance(){
        //第一次判断，如果instance的值不为 null,不需要抢占锁，直接返回对象。
        if (instance == null){
            synchronized (Singleton.class){
               //第二次判断
               if (instance == null){
                   instance = new Singleton();
               }
            }
        }
        return instance;
    }
}

这种写法还存在问题，在多线程的情况下可能会出现空指针的问题，出现问题的原因是JVM的重排序，可以使用volatile保证可见性和有序性。

/**
 * 双重检查锁方式(把读写分离，读不用锁)
 */
class Singleton{
    //1.私有构造方法
    private Singleton(){}
    
    //声明Singleton类型的变量
    private static volatile Singleton instance;
    
    //对外提供公共的访问方式
    public static Singleton getInstance(){
        //第一次判断，如果instance的值不为 null,不需要抢占锁，直接返回对象。
        if (instance == null){
            synchronized (Singleton.class){
               //第二次判断
               if (instance == null){
                   instance = new Singleton();
               }
            }
        }
        return instance;
    }
}

4️⃣ 静态内部类方式

由于JVM在加载外部类的过程中，是不会加载静态内部类的，只有静态内部类的属性/方法被调用时才会被加载。静态属性由于被static修饰，保证只被实例化一次，并且严格保证实例化顺序。

class Singleton5{
    //私有构造方法
    private Singleton5(){}
    
    //定义静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化类的对象
        private static final Singleton5 INSTANCE = new Singleton5();
    }
    
    //公共访问方式
    public static Singleton5 getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

说明：

第一次加载Singleton类时不会去初始化INSTANCE,只有第一次调用getInstance()的时候，JVM加载SingletonHolder并初始化INSTANCE。这样仅仅能保证线程安全，又能保证单例。

小结：

静态内部类推荐使用，没有性能影响和资源浪费。

存在的问题

破坏单例模式：

使上面定义的单例类可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

解决序列化单例模式被破坏的问题：

/**
 * @author 结构化思维wz
 */

public class Singleton implements Serializable {
    //私有构造方法
    private Singleton(){}

    //定义静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化类的对象
        private static final Singleton INSTANCE = new Singleton();
    }

    //公共访问方式
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }

    //当进行反序列化时，会自动调用该方法，将该方法的返回值直接返回。如果不定义会重新创建
    public Object readResolve(){
        return SingletonHolder.INSTANCE;
    }

}

解决反射破解：

package com.wangze.pattern.singleton;

/**
 * @program: code
 * @description: 解决反射破坏单例模式
 * @author: 结构化思维wz
 * @create: 2021-11-21 13:53
 **/

public class FanSingleton {
    private static boolean flag = false;
    
    //私有构造方法
    private FanSingleton(){
        synchronized (FanSingleton.class){
            //判断flag的值，如果是true说明不是第一次访问，直接抛出一个异常，如果是flag说明是第一次访问
            if(flag){
                throw new RuntimeException("单例模式，不能创建多个对象");
            }
            flag =true;
        }
    }
    //定义静态内部类
    private static class SingletonHolder{
        //在内部类中声明并初始化外部类的对象
        private static final FanSingleton INSTANCE = new FanSingleton();
    }
    
    //提供公共的访问方式
    public static FanSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }


}

---