设计模式-单例

Marlowe

设计模式

发布于：Nov 23, 2020

次浏览

3.7k words

14 min

单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

介绍

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

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

单例类只能有一个实例。
单例类必须自己创建自己的唯一实例。
单例类必须给所有其他对象提供这一实例。

使用场景：

要求生产唯一序列号。
WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
优缺点及注意

优点

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
避免对资源的多重占用（比如写文件操作）。
缺点
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
注意
getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

实现

饿汉式

package com.marlowe.singleton;

/**
 * @program: GoF23
 * @description: 饿汉式
 * @author: Marlowe
 * @create: 2020-11-23 15:07
 **/
public class Hungry {

    /**
     * 可能会浪费空间
     */
    private byte[] data1 = new byte[1024 * 1024];
    private byte[] data2 = new byte[1024 * 1024];
    private byte[] data3 = new byte[1024 * 1024];

    private Hungry() {

    }

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance() {
        return HUNGRY;
    }
}

3. 饿汉式

是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

描述：这种方式比较常用，但容易产生垃圾对象。

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

代码示例：

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

1. 懒汉式，线程不安全

是否 Lazy 初始化：是

是否多线程安全：否

实现难度：易

描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

代码示例：

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
        return instance;  
    }  
}

2. 懒汉式，线程安全

是否 Lazy 初始化：是

是否多线程安全：是

实现难度：易

描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

代码示例：

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    if (instance == null) {  
        instance = new Singleton();  
    }  
        return instance;  
    }  
}

5. 登记式/静态内部类

是否 Lazy 初始化：是

是否多线程安全：是

实现难度：一般

描述：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

代码示例：

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

6. 枚举

JDK 版本：JDK1.5 起

是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

描述：这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。

不能通过 reflection attack 来调用私有构造方法。

代码示例：

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

具体实现

枚举实现单例模式完整代码如下：

public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        System.out.println("这是枚举类型的单例模式！");
    }
}

使用枚举实现单例模式较其它两种实现方式的优势有 3 点，让我们来细品。

优势1：优势 1 ：一目了然的代码

代码对比饿汉式与懒汉式来说，更加地简洁。最少只需要3行代码，就可以完成一个单例模式：

1
2
3

public enum Test {
    INSTANCE;
}

我们从最直观的地方入手，第一眼看到这3行代码，就会感觉到少，没错，就是少，虽然这优势有些牵强，但写的代码越少，越不容易出错。

优势 2：天然的线程安全与单一实例

它不需要做任何额外的操作，就可以保证对象单一性与线程安全性。

我写了一段测试代码放在下面，这一段代码可以证明程序启动时仅会创建一个 Singleton 对象，且是线程安全的。

我们可以简单地理解枚举创建实例的过程：在程序启动时，会调用 Singleton 的空参构造器，实例化好一个Singleton 对象赋给 INSTANCE，之后再也不会实例化

public enum Singleton {
    INSTANCE;
    Singleton() { System.out.println("枚举创建对象了"); }
    public static void main(String[] args) { /* test(); */ }
    public void test() {
        Singleton t1 = Singleton.INSTANCE;
        Singleton t2 = Singleton.INSTANCE;
        System.out.print("t1和t2的地址是否相同：" + t1 == t2);
    }
}
// 枚举创建对象了
// t1和t2的地址是否相同：true

除了优势1和优势2，还有最后一个优势是 保护单例模式，它使得枚举在当前的单例模式领域已经是 无懈可击 了。

优势 3：枚举保护单例模式不被破坏

使用枚举可以防止调用者使用反射、序列化与反序列化机制强制生成多个单例对象，破坏单例模式。

防反射

枚举类默认继承了 Enum 类，在利用反射调用 newInstance() 时，会判断该类是否是一个枚举类，如果是，则抛出异常。

防止反序列化创建多个枚举对象

在读入 Singleton 对象时，每个枚举类型和枚举名字都是唯一的，所以在序列化时，仅仅只是对枚举的类型和变量名输出到文件中，在读入文件反序列化成对象时，使用 Enum 类的 valueOf(String name) 方法根据变量的名字查找对应的枚举对象。

所以，在序列化和反序列化的过程中，只是写出和读入了枚举类型和名字，没有任何关于对象的操作。

小结：

（1）Enum 类内部使用Enum 类型判定防止通过反射创建多个对象

（2）Enum 类通过写出（读入）对象类型和枚举名字将对象序列化（反序列化），通过 valueOf() 方法匹配枚举名找到内存中的唯一的对象实例，防止通过反序列化构造多个对象

（3）枚举类不需要关注线程安全、破坏单例和性能问题，因为其创建对象的时机与饿汉式单例有异曲同工之妙。

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

4. DCL(Double CheckLock 双重校验锁(线程安全、效率高))懒汉式，深究！

注意： 如果不使用volatile关键词修饰，可能会导致拿到的对象是未被初始化的。
具体原因见代码注释部分

package com.marlowe.singleton;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * @program: GoF23
 * @description: 懒汉式
 * @author: Marlowe
 * @create: 2020-11-23 15:11
 **/
public class LazyMan {
    private static boolean marlowe = false;

    private LazyMan() {
        synchronized (LazyMan.class) {
            if (marlowe == false) {
                marlowe = true;
            } else {
                throw new RuntimeException("不要试图使用反射破坏异常");
            }

        }
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private volatile static LazyMan lazyMan;

    /**
     * 双重检测所模式的 懒汉式单例 DCL懒汉式
     *
     * @return
     */
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    // 创建对象不是原子性操作，可能导致对象未初始化
                    lazyMan = new LazyMan();
                    /**
                     * 分三步完成
                     * 
                     * 1. 分配内存空间
                     * 2. 执行构造方法，初始化对象
                     * 3. 把这个对象指向分配的内存空间
                     *
                     * 预期执行顺序  1->2->3
                     * 由于JVM具有指令重排的特性 实际顺序可能是1->3->2
                     * 指令重排在单线程的环境下不会出现问题，但是在多线程环境下可能会导致一个线程获得还没有初始化的实例
                     * 例如：A线程执行了1,3，此时B线程调用getInstance() 后发现 lazyMan 不为空，因此直接返回 lazyMan
                     * 但此时 lazyMan 还未被初始化。使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行
                     *
                     */
                }
            }
        }
        return lazyMan;
    }

    /**
     * 反射
     *
     * @param args
     */
    public static void main(String[] args) throws Exception {
        Field marlowe = LazyMan.class.getDeclaredField("marlowe");
        marlowe.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance2 = declaredConstructor.newInstance();

        marlowe.set(instance, false);
        System.out.println(instance);
        System.out.println(instance2);

    }

}

DCL单例为什么要加volatile

我们把上面写的DDL单例拿过来，加入不加volatile，如下：

public class SingleInstance {
    private SingleInstance() {}
    private static SingleInstance INSTANCE;
    public static SingleInstance getInstance() {
        if (INSTANCE == null) {
            synchronized (SingleInstance.class) {
                if (INSTANCE == null) {
                    INSTANCE = new SingleInstance();
                }
            }
        }
        return INSTANCE;
    }
}

当 INSTANCE = new SingleInstance() 创建实例对象时，并不是原子操作，它是分三步来完成的：

创建内存空间。
执行构造函数，初始化（init）
将INSTANCE引用指向分配的内存空间

上述正常步骤按照1–>2–>3来执行的，但是，我们知道，JVM为了优化指令，提高程序运行效率，允许指令重排序。正是有了指令重排序的存在，那么就有可能按照1–>3–>2步骤来执行，这时候，当线程a执行步骤3完毕，在执行步骤2之前，被切换到线程b上，这时候instance判断为非空，此时线程b直接来到return instance语句，拿走instance然后使用，接着就顺理成章地报错（对象尚未初始化）。

synchronized虽然保证了线程的原子性（即synchronized块中的语句要么全部执行，要么一条也不执行），但单条语句编译后形成的指令并不是一个原子操作（即可能该条语句的部分指令未得到执行，就被切换到另一个线程了）。

volatile关键字其中一个作用就是禁止指令重排序，所以DCL单例必须要加volatile

volatile作用：

保证被修饰的变量对所有线程的可见性。
禁止指令重排序优化。

静态内部类

package com.marlowe.singleton;

/**
 * @program: GoF23
 * @description: 静态内部类
 * @author: Marlowe
 * @create: 2020-11-23 15:32
 **/
public class Holder {
    private Holder() {

    }

    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }

    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }
}

单例不安全，因为有反射

package com.marlowe.singleton;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @program: GoF23
 * @description: enum 是什么？ 本身也是一个class类
 * @author: Marlowe
 * @create: 2020-11-23 15:49
 **/
public enum EnumSingleton {
    INSTANCE;

    public EnumSingleton getInstance() {
        return INSTANCE;
    }

}

class Test {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        EnumSingleton instance1 = EnumSingleton.INSTANCE;
        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingleton instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

枚举类型的最终反编译原码里面是有参构造方法

经验之谈

单例对象占用资源少，不需要延时加载，枚举好于饿汉
单例对象占用资源多，需要延时加载，静态内部类好于懒汉式

参考文献

设计模式-单例模式

Marlowe

更新于：Sep 1, 2021

设计模式-代理

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。介绍在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中...

设计模式-工厂

工厂设计模式很常用，分为简单工厂，工厂方法和抽象工厂。核心本质实例化对象不使用new，用工厂方法代替将选择实现类，创建对象统一管理和控制。从而将调用者跟我们实现类解耦 OOP七大原则...

设计模式-单例

介绍

优缺点及注意

优点

缺点

注意

实现

饿汉式

3. 饿汉式

1. 懒汉式，线程不安全

2. 懒汉式，线程安全

5. 登记式/静态内部类

6. 枚举

具体实现

优势1：优势 1 ：一目了然的代码

优势 2：天然的线程安全与单一实例

优势 3：枚举保护单例模式不被破坏

小结：

4. DCL(Double CheckLock 双重校验锁(线程安全、效率高))懒汉式，深究！

DCL单例为什么要加volatile

静态内部类

单例不安全，因为有反射

经验之谈

参考文献