一起来学设计模式之单例模式

怼烎@ 2024-03-24 10:38 77阅读 0赞

### 前言 ###

本节给大家讲一下设计模式中的`单例模式`~

### 单例模式 ###

`单例模式`是一种创建型设计模式，它确保一个类`只有一个实例`，并提供一个`全局访问点`。

`单例模式`适用于需要确保系统中只有一个实例，并且需要提供`一个全局访问点`的场景，比如`线程池、日志系统、配置文件管理器`等。

下面看一个简单的例子:

#### 懒汉式(线程不安全) ####

public class Singleton01 {
        private static Singleton01 instance;
    
        private Singleton01() {
            // 构造函数私有化，确保只能通过getInstance()方法获取实例
        }
    
        public static Singleton01 getInstance() {
            if (instance == null) {
                System.out.println("instance = null");
                instance = new Singleton01();
            }
            return instance;
        }
    
        public static void main(String[] args) {
            Singleton01 singleton01 = Singleton01.getInstance();
            System.out.println(singleton01.hashCode());
    
            Singleton01 singleton02 = Singleton01.getInstance();
            System.out.println(singleton02.hashCode());
            System.out.println(singleton01.equals(singleton02));
        }
    }
    复制代码

运行下:

instance = null
    460141958
    460141958
    true
    复制代码

从结果来看是同一个实例对象。

在这个实现中，我们通过将构造函数`私有化`，确保了外部无法通过`new操作符`来创建实例。而`getInstance()`方法则提供了一个`全局访问点`，通过懒加载的方式来创建实例，确保只有在`需要`使用时才会创建实例,从而节省资源。

这里需要注意的是，由于`getInstance()`方法是`静态`方法，所以需要将`instance`变量声明为`静态变量`。

上述模式又叫`懒汉式`，是`线程不安全`的~

#### 饿汉式（线程安全） ####

那么思考一下，上述不安全的问题主要存在于哪?

线程不安全问题主要是由于`instance`被多次实例化，那么采取直接实例化`instance`的方式就不会产生线程不安全问题。但是会浪费资源

// 饿汉式
    private static Singleton01 instance = new Singleton01();
    复制代码

#### 懒汉式(线程安全) ####

为了确保线程安全，那有什么办法让懒汉式线程安全呢?我们只需要对`getInstance()`方法进行同步加锁,那么在一个时间点只能有一个线程能够进入该方法,从而避免了被多次实例化,因为加了`锁`，所以线程进入方法的时候就需要进行等待，`性能`上就会有有一点损耗

public static synchronized  Singleton01 getInstance() {
        if (instance == null) {
            System.out.println("instance = null");
            instance = new Singleton01();
        }
        return instance;
    }
    复制代码

#### 双重校验锁（线程安全） ####

`instance` 只需要被实例化一次之后就可以直接使用了。`加锁`操作只需要对`实例化`那部分的代码进行，只有当 `instance` 没有被实例化时，才需要进行加锁。`双重校验锁`先判断 `instance` 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行`加锁`。下面看下代码实现:

public class Singleton02 {
        private volatile static Singleton02 instance;
    
        private Singleton02() {
        }
    
        public static Singleton02 getInstance() {
            if (instance == null) {
                synchronized (Singleton02.class) {
                    if (instance == null) {
                        instance = new Singleton02();
                    }
                }
            }
            return instance;
        }
    }
    复制代码

同时，我们也可以看到使用了`volatile`关键字，这个在之前的文章给大家详细讲过。这里简单给大家提一下，为什么用它~

在`Java`中，由于`JVM`存在`指令重排序`和`线程可见性`的问题，当一个线程在使用一个对象的时候，另外一个线程可能会看到一个`不完整`的对象状态，导致程序出现一些意想不到的错误。这个问题在多线程环境下非常常见。

为了解决这个问题，`Java`提供了一种关键字叫做`volatile`，它可以禁止`JVM指令重排`。它可以确保变量的`可见性和有序性`。在多线程环境下，当一个线程修改了`volatile`变量时，它会立即`刷新到主存`中，而其他线程在访问该变量时会`强制从主存中重新读取最新`的值，从而避免了读取到不完整的对象状态。

在`单例模式`的实现中，由于`instance`变量在`getInstance()`方法中被`多个线程共享`，因此需要使用`volatile`关键字来确保变量的`可见性和有序性`，从而避免了多线程环境下的`并发访问`问题。

思考一下，这里为啥要使用两个`if`语句,明明在最外层已经判断了`if (instance == null)`而且里边已经加了`锁`了，在里边为什么还要`if`判断呢?

有时候，面试官会这么问？有的同学就答不上来了。大家不妨想象一下，当两个线程同时进入加锁的方法内,在没有判断的情况下`instance`对象还是会被实例化`2`次,因为代码块的语句是正常执行的,只是执行先后的问题~

#### 静态内部类(线程安全) ####

当 `Singleton03` 类加载时，静态内部类 `Singleton` 没有被加载进内存。只有当调用 `getInstance()` 方法从而触发 `Singleton.INSTANCE` 时 `Singleton` 才会被加载，此时初始化 `INSTANCE` 实例。这种方式不仅具有`延迟`初始化的好处，而且由虚拟机提供了对`线程安全`的支持。

public class Singleton03 {
        private Singleton03() {
        }
    
        private static class Singleton {
            private static final Singleton03 INSTANCE = new Singleton03();
        }
    
        public static Singleton03 getInstance() {
            return Singleton.INSTANCE;
        }
    }
    复制代码

#### 枚举模式 (线程安全，最佳实践) ####

使用`枚举实现`的`单例模式`是一种`简洁而又安全`的方式，这种方式可以避免多线程环境下的并发问题，同时也可以`防止反射和反序列化攻击`。

在使用枚举实现单例模式时，只需要定义一个枚举类型，并在其中定义一个单例对象即可。由于枚举类型在`Java`中是天然的`单例模式`，因此这种方式可以保证在任何情况下都`只创建一个实例对象`。

public enum Singleton04 {
        INSTANCE;
    
        private String message = "Hello World!";
    
        public void showMessage() {
            System.out.println(message);
        }
    }
    复制代码

调用:

public class Application {
        public static void main(String[] args) {
            Singleton04.INSTANCE.showMessage();
        }
    }
    复制代码

输出:

Hello World!
    复制代码

### 反射 & 反序列化攻击 ###

#### 反射攻击 ####

有的小伙伴可能不知道，这里给大家扩展一下，下面通过一个简单的例子，看了之后就会明白了

`反射攻击和反序列化攻击`是两种常见的安全问题，它们都可以被用来`攻击单例模式`的实现。

`反射攻击`是指通过`Java`的`反射机制`来获取类的私有构造方法，然后通过构造方法创建类的实例对象，从而破坏单例模式的实现。由于`Java`的反射机制可以`访问私有`的构造方法，因此攻击者可以通过这种方式来`创建`多个实例对象，从而破坏单例模式的唯一性。

public class Singleton05 {
        private static Singleton05 instance = new Singleton05();
    
        private Singleton05() {
            if (instance != null) {
                throw new IllegalStateException("Singleton already initialized");
            }
        }
    
        public static Singleton05 getInstance() {
            return instance;
        }
    
        public static void main(String[] args) throws Exception {
            Constructor<Singleton05> constructor = Singleton05.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            Singleton05 instance1 = constructor.newInstance();
            Singleton05 instance2 = Singleton05.getInstance();
            System.out.println(instance1 == instance2);
        }
    }
    复制代码

运行一下：

//        Exception in thread "main" java.lang.reflect.InvocationTargetException
    //        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    //        at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    //        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    //        at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    //        at com.java.design.single.Singleton05.main(Singleton05.java:26)
    //        Caused by: java.lang.IllegalStateException: Singleton already initialized
    //        at com.java.design.single.Singleton05.<init>(Singleton05.java:15)
    //	... 5 more
    复制代码

好家伙，直接干报错，原因也很简单，因为利用反射修改了`构造方法`的访问权限，然后进行了实例化,当再次运行进入`if (instance != null)`就会抛出异常

#### 序列化攻击 ####

`反序列化攻击`是指攻击者通过`序列化`和`反序列化`技术来破坏单例模式的实现。攻击者可以通过`序列化`和`反序列化`来创建`多个实例`对象，从而破坏单例模式的唯一性。这种攻击方式常常被用于分布式系统中，攻击者可以在一个系统中序列化一个对象，然后在另一个系统中反序列化该对象，从而创建多个实例对象。

下面通过一个简单例子来看一下:

public class Singleton06 implements Serializable {
        private static final long serialVersionUID = 1L;
    
        private static Singleton06 instance = new Singleton06();
    
        private Singleton06() {
            if (instance != null) {
                throw new IllegalStateException("Singleton already initialized");
            }
        }
    
        public static Singleton06 getInstance() {
            return instance;
        }
    
        public static void main(String[] args) throws Exception {
            Singleton06 instance1 = Singleton06.getInstance();
    
            // 将实例对象序列化到文件中
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("singleton.ser"));
            out.writeObject(instance1);
            out.close();
    
            // 从文件中反序列化出实例对象
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("singleton.ser"));
            Singleton06 instance2 = (Singleton06) in.readObject();
            in.close();
    
            System.out.println(instance1 == instance2); // false
        }
    }
    复制代码

输出为 `false`从而达到了破坏,既然问题知道了，那怎么去防止攻击呢?其实很简单, 为了防止反序列化攻击，可以在单例类中添加一个`readResolve()`方法，用来替换从反序列化流中反序列化出的对象，确保只有单例对象的引用被返回

public class Singleton06 implements Serializable {
        private static final long serialVersionUID = 1L;
    
        private static Singleton06 instance = new Singleton06();
    
        private Singleton06() {
            if (instance != null) {
                throw new IllegalStateException("Singleton already initialized");
            }
        }
    
        public static Singleton06 getInstance() {
            return instance;
        }
    
        // 保护措施
        protected Object readResolve() {
            return instance;
        }
    
        public static void main(String[] args) throws Exception {
            Singleton06 instance1 = Singleton06.getInstance();
    
            // 将实例对象序列化到文件中
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("singleton.ser"));
            out.writeObject(instance1);
            out.close();
    
            // 从文件中反序
            // 从文件中反序列化出实例对象
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("singleton.ser"));
            Singleton06 instance2 = (Singleton06) in.readObject();
            in.close();
    
            System.out.println(instance1 == instance2); // true
        }
    }
    复制代码

看下输出: `true`,在这个示例代码中，我们添加了一个`readResolve()`方法，该方法返回`单例对象的引用`。当从反序列化流中`反序列化`出一个对象时，该方法会被`自动调用`，从而`确保只有单例对象的引用`被返回。