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

Posted 2021-12-15 结构化思维wz

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式 | 单例模式的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;

以上是关于设计模式 | 单例模式的7种写法的主要内容，如果未能解决你的问题，请参考以下文章