【设计模式】1.单例模式

快来打我* 2024-04-01 19:09 43阅读 0赞

#### 文章目录 ####

*  1. 创建者模式概述
 *  2. 单例模式概述
 *   *  2.1 饿汉式
     *   *  2.1.1 通过静态变量的方式实现饿汉式
         *  2.1.2 通过静态代码块方式实现
     *  2.2 懒汉式
     *   *  2.2.1 懒汉式——线程不安全
         *  2.2.2 懒汉式——线程安全
         *  2.2.3 懒汉式——双重校验锁——线程安全
         *  2.2.4 懒汉式——静态内部类
         *  2.2.5 懒汉式——枚举
 *  3. 破坏单例模式与解决方案
 *   *  3.1 使用序列化破坏单例模式
     *  3.2 解决序列化导致单例模式破坏问题
     *  3.3 使用反射破坏单例模式
     *  3.4 解决反射导致的单例模式破坏问题
 *  4. 源码中单例模式的使用场景
 *  5. 单例模式相关面试题

## 1. 创建者模式概述 ##

创建型模式的主要关注点是“怎样创建对象？”，**它的主要特点是“将对象的创建与使用分离”。**

\*\*这样可以降低系统的耦合度，\*\*使用者不需要关注对象的创建细节。

创建型模式分为：

*  单例模式
 *  工厂方法模式
 *  抽象工程模式
 *  原型模式
 *  建造者模式

--------------------

## 2. 单例模式概述 ##

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

该模式确保了只有单个对象被创建，并且这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类对象。

单例模式分类有以下两种：

*  饿汉式：类加载的时候会导致该单实例被加载
 *  懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

--------------------

### 2.1 饿汉式 ###

实现饿汉式有两种方式实现：

*  通过静态变量的方式实现
 *  通过静态代码块方式实现

--------------------

#### 2.1.1 通过静态变量的方式实现饿汉式 ####

/**
     * 饿汉式
     *      静态变量创建类的对象
     */
    public class Singleton {
        
        //私有构造方法
        private Singleton() {
        }
    
        //在成员位置创建该类的对象
        private static Singleton instance = new Singleton();
    
        //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
            return instance;
        }
    }

> 该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。**instance对象是随着类的加载而创建的。**
> 
> 但是缺点就是**如果该对象足够大的话，而一直没有使用就会造成内存的浪费。**
> 
> **这种饿汉式是线程安全的，因为instance对象只会被实例化一次。**

--------------------

#### 2.1.2 通过静态代码块方式实现 ####

/**
     * 饿汉式
     *      在静态代码块中创建该类对象
     */
    public class Singleton {
        
    
        //私有构造方法
        private Singleton() {
        }
    
        //在成员位置创建该类的对象
        private static Singleton instance;
    
        static {
        
            instance = new Singleton();
        }
    
        //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
            return instance;
        }
    }

> 该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是**随着类的加载而创建**。所以和饿汉式的方式1基本上一样，\*\*当然该方式也存在内存浪费问题。\*\*同时也是线程

--------------------

### 2.2 懒汉式 ###

懒汉式有有五种方式实现：

*  懒汉式——线程不安全
 *  懒汉式——线程安全
 *  懒汉式——双重校验锁——线程安全
 *  懒汉式——静态内部类
 *  懒汉式——枚举

--------------------

#### 2.2.1 懒汉式——线程不安全 ####

/**
     * 懒汉式
     *  线程不安全
     */
    public class Singleton {
        
        //私有构造方法
        private Singleton() {
        }
    
        //在成员位置创建该类的对象
        private static Singleton instance;
    
        //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
    
            if(instance == null) {
        
                instance = new Singleton();
            }
            return instance;
        }
    }

> 从上述代码可以看出，当调用getInstance()方法获取Singleton类的对象的时候如果Singleton没有实例化，那么就创建Singleton对象。
> 
> **为什么这种方式是线程不安全的呢？**
> 
> 假如大量线程同时判断if(instance == null)，肯定都为true，就会进去创建Singleton，导致Singleton对象被多次实例化。

--------------------

#### 2.2.2 懒汉式——线程安全 ####

/**
     * 懒汉式
     *  线程安全
     */
    public class Singleton {
        
        //私有构造方法
        private Singleton() {
        }
    
        //在成员位置创建该类的对象
        private static Singleton instance;
    
        //对外提供静态方法获取该对象
        public static synchronized Singleton getInstance() {
        
    
            if(instance == null) {
        
                instance = new Singleton();
            }
            return instance;
        }
    }

> 上述这种方式，就既解决了线程安全问题，又实现了懒加载效果。
> 
> 在getInstance()方法上添加了synchronized关键字，这样执行效果特别低。但是实际上，只有在初始化的时候才会出现线程安全问题，一旦初始化之后就不存在了。
> 
> 因此还可以继续优化。

#### 2.2.3 懒汉式——双重校验锁——线程安全 ####

/**
     * 双重检查方式
     */
    public class Singleton {
         
    
        //私有构造方法
        private Singleton() {
        }
    
        private static Singleton instance;
    
       //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
    		//第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
            if(instance == null) {
        
                synchronized (Singleton.class) {
        
                    //抢到锁之后再次判断是否为null
                    if(instance == null) {
        
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

> 上述这种实现方案不在类方法上加锁，而是在第一次判断instance 是否等于 null之后进行加锁。若抢占到锁，进去还需要进行二次判断，因此可能前一次获取锁的线程已经将Singleton实例化出来了，如果已经实例化出来，那么就不需要再次实例化了。
> 
> **双重检查锁模式是一种非常好的单例实现模式**，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，**在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。**
> 
> 要解决双重检查锁模式带来空指针异常的问题，只需要使用 `volatile` 关键字, `volatile` 关键字可以保证可见性和有序性。

/**
     * 双重检查方式
     */
    public class Singleton {
        
    
        //私有构造方法
        private 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;
        }
    }

--------------------

#### 2.2.4 懒汉式——静态内部类 ####

/**
     * 静态内部类方式
     */
    public class Singleton {
        
    
        //私有构造方法
        private Singleton() {
        }
    
        private static class SingletonHolder {
        
            private static final Singleton INSTANCE = new Singleton();
        }
    
        //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
            return SingletonHolder.INSTANCE;
        }
    }

> 当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 `getInstance()` 方法从而触发 `SingletonHolder.INSTANCE` 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例。
> 
> 这种方式不仅具有延迟初始化的好处，而且由虚拟机提供了对线程安全的支持。
> 
> 静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

--------------------

#### 2.2.5 懒汉式——枚举 ####

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

> 这是单例模式的最佳实践，它实现简单，并且在面对复杂的序列化或者反射攻击的时候，能够防止实例化多次。
> 
> **枚举类实现单例模式是极力推荐的单例实现模式**，因为枚举类型是线程安全的，并且只会装载一次，**设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。**

--------------------

## 3. 破坏单例模式与解决方案 ##

上面定义的单例模式，除了枚举方式外，其他都能破坏。

破坏单例模式有两种方式：

1.  序列化
2.  反射

--------------------

### 3.1 使用序列化破坏单例模式 ###

Singleton继承Serializable接口

Test类

public class Test {
        
        public static void main(String[] args) throws Exception {
        
            //往文件中写对象
            //writeObject2File();
            //从文件中读取对象
            Singleton s1 = readObjectFromFile();
            Singleton s2 = readObjectFromFile();
    
            //判断两个反序列化后的对象是否是同一个对象
            System.out.println(s1 == s2);
        }
    
        private static Singleton readObjectFromFile() throws Exception {
        
            //创建对象输入流对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt"));
            //第一个读取Singleton对象
            Singleton instance = (Singleton) ois.readObject();
    
            return instance;
        }
    
        public static void writeObject2File() throws Exception {
        
            //获取Singleton类的对象
            Singleton instance = Singleton.getInstance();
            //创建对象输出流
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt"));
            //将instance对象写出到文件中
            oos.writeObject(instance);
        }
    }

> 上述代码运行的结果是false，表明序列化和反序列化已经破坏了单例设计模式。

--------------------

### 3.2 解决序列化导致单例模式破坏问题 ###

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;
        }
        
        /**
         * 下面是为了解决序列化反序列化破解单例模式
         */
        private Object readResolve() {
        
            return SingletonHolder.INSTANCE;
        }
    }

> 在Singleton类中添加`readResolve()`方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

--------------------

### 3.3 使用反射破坏单例模式 ###

Singleton类

public class Singleton {
        
    
        //私有构造方法
        private Singleton() {
        }
        
        private static volatile Singleton instance;
    
        //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
    
            if(instance != null) {
        
                return instance;
            }
    
            synchronized (Singleton.class) {
        
                if(instance != null) {
        
                    return instance;
                }
                instance = new Singleton();
                return instance;
            }
        }
    }

Test类

public class Test {
        
        public static void main(String[] args) throws Exception {
        
            //获取Singleton类的字节码对象
            Class clazz = Singleton.class;
            //获取Singleton类的私有无参构造方法对象
            Constructor constructor = clazz.getDeclaredConstructor();
            //取消访问检查
            constructor.setAccessible(true);
    
            //创建Singleton类的对象s1
            Singleton s1 = (Singleton) constructor.newInstance();
            //创建Singleton类的对象s2
            Singleton s2 = (Singleton) constructor.newInstance();
    
            //判断通过反射创建的两个Singleton对象是否是同一个对象
            System.out.println(s1 == s2);
        }
    }

> 运行结果为false，说明反射已经破开的单例情况。

### 3.4 解决反射导致的单例模式破坏问题 ###

public class Singleton {
        
    
        //私有构造方法
        private Singleton() {
        
            /*
               反射破解单例模式需要添加的代码
            */
            if(instance != null) {
        
                throw new RuntimeException();
            }
        }
        
        private static volatile Singleton instance;
    
        //对外提供静态方法获取该对象
        public static Singleton getInstance() {
        
    
            if(instance != null) {
        
                return instance;
            }
    
            synchronized (Singleton.class) {
        
                if(instance != null) {
        
                    return instance;
                }
                instance = new Singleton();
                return instance;
            }
        }
    }

> 在Singleton的私有构造方法中判断一下instance是否为null，若不是，证明之前已经实例化过，因此抛出异常即可。

--------------------

## 4. 源码中单例模式的使用场景 ##

在JDK源码中，Runtime类使用的就是单例设计模式

public class Runtime {
        
        private static Runtime currentRuntime = new Runtime();
    
        /**
         * Returns the runtime object associated with the current Java application.
         * Most of the methods of class <code>Runtime</code> are instance
         * methods and must be invoked with respect to the current runtime object.
         *
         * @return  the <code>Runtime</code> object associated with the current
         *          Java application.
         */
        public static Runtime getRuntime() {
        
            return currentRuntime;
        }
    
        /** Don't let anyone else instantiate this class */
        private Runtime() {
        }
        ...
    }

--------------------

## 5. 单例模式相关面试题 ##

> 说说你对单例模式的理解？

*  单例模式是一种很常用的设计模式，单例模式比较简单但包含了关于线程安全、内存模型、类加载机制等一些比较核心的知识点。
 *  单例模式使得一个类只有一个实例对象/
 *  有些对象的创建销毁对资源的消耗比较大，如果频繁的创建和销毁对象并且这些对象完全是可以复用的话，那么将会造成一些不必要的性能浪费（比如JDBC数据库的连接）。

> 单例模式有什么特点？

*  类构造器私有
 *  提供获取实例的静态方法

> 饿汉式与懒汉式的区别？

*  从线程安全方面，饿汉式天生就是线程安全的，而懒汉式本身是非线程安全的。
 *  从资源加载与性能方面，**饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存**，但是相应的，第一次调用的时候速度也很快，因此资源在类加载的时候已经创建完成了。**而懒汉式会延迟加载，只有第一次使用该实例对象的时候才会创建出来，因此第一次需要做初始化，效率性能有所下降**。

--------------------

> 参考：
> 
>  *  [java面试题——单例模式5道常见面试题\_码云铁粉的博客-CSDN博客\_java单例模式笔试题][java_5_-CSDN_java]
>  *  [黑马程序员Java设计模式详解， 23种Java设计模式（图解+框架源码分析+实战）][Java_ 23_Java]

[java_5_-CSDN_java]: https://blog.csdn.net/m0_63270506/article/details/124576074
[Java_ 23_Java]: https://www.bilibili.com/video/BV1Np4y1z7BU/