[设计模式] 浅谈单例模式

2024 年 4 月 22 日 星期一(已编辑)
/ ,
11
这篇文章上次修改于 2024 年 4 月 22 日 星期一，可能部分内容已经不适用，如有疑问可询问作者。

阅读此文章之前，你可能需要首先阅读以下的文章才能更好的理解上下文。

单例模式

模式功能说明：保证一个类只有一个实例，并提供一个全局访问点。这样可以避免在多个地方创建对象，从而节省系统资源，提高效率。

两种方式

饿汉式

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

在类加载时就完成了初始化,就不会产生线程不安全问题。但类加载较慢，但获取对象的速度快，是一种典型的以时间换空间的做法。

懒汉式

线程不安全

public class Singleton {

    private static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 uniqueInstance = new Singleton(); 语句，这将导致多次实例化 uniqueInstance。

线程安全

public static synchronized Singleton getUniqueInstance() {
    if (uniqueInstance == null) {
        uniqueInstance = new Singleton();
    }
    return uniqueInstance;
}

对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了多次实例化 uniqueInstance 的问题。但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，因此性能上有一定的损耗。
存在问题1：在 uniqueInstance == null 的情况下，如果两个线程同时执行 if 语句，那么两个线程就会同时进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句，只是先后的问题，那么就会进行两次实例化，从而产生了两个实例。
存在问题2：uniqueInstance = new Singleton(); 这段代码其实是分为三步执行。

  1. 分配内存
  2. 空间初始化
  3. 对象将 uniqueInstance 指向分配的内存地址
    但是由于 JVM 具有指令重排的特性，有可能执行顺序变为了 1>3>2，这在单线程情况下自然是没有问题。但如果是多线程下，有可能获得是一个还没有被初始化的实例，以致于程序出错。

双重校验锁-线程安全

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。 使用两个 if 语句避免产生了两个实例

静态内部类实现


public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
}

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

枚举实现

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("Do something");
    }
}

枚举实现单例模式是最简洁、易用且线程安全的一种方式。在Java中，每一个枚举类型及其定义的枚举变量在JVM中都只存在一份，保证了枚举类型的实例是单例的。 这种方式实现的单例模式不仅能保证线程安全，还能防止反序列化重新创建新的对象，绝对防止多次实例化，是实现单例模式的最佳方法。

总结

实现方式原理优点缺点
饿汉式依赖JVM的加载机制，保证单例只会创建一次线程安全、获取快创建不可控
普通懒汉式按需加载节约资源线程不安全
同步锁模式synchronized线程安全性能差
双重锁模式synchronized、volatile、多重判断线程安全、节约资源实现复杂
静态内部类模式按需加载线程安全、节约资源、实现简单无
枚举类模式依赖枚举机制线程安全、只有序列化、简洁创建实际不可控
  • Loading...
  • Loading...
  • Loading...
  • Loading...
  • Loading...