单例模式的7种实现方式及比较

时间：2025-03-25 19:55:52

单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的一个类只有一个实例，即一个类只有一个对象实例。 – 百度百科

问题的由来

多个线程要操作同一对象，需要保证对象的唯一性。

解决思路

  • 该类的构造方法为私有，防止外部实例化该类的对象
  • 该类中要有一个对象实例化过程（只有一次）
  • 该类需要提供返回实例对象的方法

解决方案

为了更好的对下面即将介绍的几种实现方式进行比较，我们定义几个考量维度：线程的安全线、是否懒加载、性能。

方法一：饿汉式单例模式【可用】
public class BadmashSingleton {
    // 在类加载的时候即被实例化
    private static BadmashSingleton instance = new BadmashSingleton();
    private BadmashSingleton() {
    }

    public static BadmashSingleton getInstance() {
        return instance;
    }
}
  • 线程安全性： 实例在类加载的时候即被实例化，因此线程安全。
  • 是否懒加载： 没有延迟加载，如果长时间没用到这个实例，则会造成内存的浪费。
  • 性能： 性能比较好
方法二：懒汉式单例模式【多线程有问题】
public class IdlerSingleton {
    private static IdlerSingleton instance = null;
    private IdlerSingleton() {
    }
	// 在使用时才进行加载
    public static IdlerSingleton getInstance() {
        if (null == instance) {
            instance = new IdlerSingleton();
        }
        return instance;
    }
}
  • 线程安全性： 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。
    • 问题出现在if (null == instance)这一步，多线程环境中可能会有多个线程同时拿到instance的值为null。
  • 是否懒加载： 懒加载
  • 性能： 性能比较好
方法三：懒汉式单例模式+同步方法【性能差，不推荐使用】
public class IdlerSynSingleton {
    private static IdlerSynSingleton instance = null;
    private IdlerSynSingleton() {
    }

    public static synchronized IdlerSynSingleton getInstance() {
        if (null == instance) {
        	instance = new IdlerSynSingleton();
        }
        return instance;
    }
}
  • 线程安全性： 线程安全
  • 是否懒加载： 懒加载
  • 性能： synchronized修饰方法，使得多线程执行退化为串行执行，性能差
方法四：懒汉式单例模式+同步代码块【不可用】

该方法是对上面方法的一个优化，将同步方法改为同步代码块。

public class IdlerSynSingleton {
    private static IdlerSynSingleton instance = null;
    private IdlerSynSingleton() {
    }

    public static IdlerSynSingleton getInstance() {
        if (null == instance) {
            synchronized () {
                instance = new IdlerSynSingleton();
            }
        }
        return instance;
    }
}
  • 线程安全性： 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。
    • 问题同样出现在if (null == instance)这一步
  • 是否懒加载： 懒加载
  • 性能： 性能一般
方法五：DCL单例模式+Volatile【可用】

为了解决方法四存在的线程不安全问题，我们引入双重锁，即Double-Check-Locking。同时引入volatile关键字修饰实例对象，这是为了避免因JVM指令重排序可能导致的空指针异常。因为当线程执行到第一个if (null == instance)时，代码可能读取到instance不为null，但此时instance引用的对象可能还没有完成初始化。

public class DCLSingleton {
    private static volatile DCLSingleton instance = null;
    private DCLSingleton() {
    }

    public static DCLSingleton getInstance() {
        if (null == instance) {
            synchronized () {
                if (null == instance) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}
  • 线程安全性： 线程安全性
  • 是否懒加载： 懒加载
  • 性能： 性能比较好
方法六：Holder单例模式【推荐】

声明类时，成员变量中不声明实例变量，而是放到静态内部类中。这种方式和懒汉式有些相似，它们都采用了类装载的机制来保证初始化实例时只有一个线程，不同的是，Holder单例模式是将实例的初始化放到了静态类中去实现，从而实现了懒加载。

public class HolderSingleton {
    private static HolderSingleton instance = null;
    private HolderSingleton() {
    }

    public static HolderSingleton getInstance() {
        return ;
    }

    private static class Holder {
        private static HolderSingleton instance = new HolderSingleton();
    }
}
  • 线程安全性： 线程安全性
  • 是否懒加载： 懒加载
  • 性能： 性能好
方法七：Enum单例模式【推荐】

借助了enum枚举类的特性，直接解决了多线程同步问题。

public class EnumSingleton {
    private EnumSingleton() {
    }

    public static EnumSingleton getInstance() {
        return ();
    }

    private enum EnumHolder {
        INSTANCE;
        private EnumSingleton instance = null;

        private EnumHolder() {
            instance = new EnumSingleton();
        }

        private EnumSingleton getInstance() {
            return instance;
        }
    }
}
  • 线程安全性： 线程安全性
  • 是否懒加载： 懒加载
  • 性能： 性能好

总结

本文共列举了七种单例模式的实现方式，推荐使用后面两种方式。

------------本文结束感谢您的阅读------------

相关文章