Java 单例模式

罗伯特_十三2024-09-15 12:04

文章目录

前言

最近看Effective Java看到了一点关于单例模式的内容，结合自己所知，在此做个总结归纳。

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，用于限制一个类的实例化次数，确保在整个程序运行期间，该类只有一个实例存在，并提供一个全局访问点来访问这个实例。

单例模式的几种实现方式

普遍来说，单例模式的实现主要有两种方式：

  • 饿汉式：类加载时该单实例对象被创建。
  • 懒汉式：首次使用该对象时，该单实例对象才会被创建。

补充：

  • 枚举
饿汉式
  • 思路：在类加载时就创建好一个静态实例，因此类加载器保证了单例的唯一性。
饿汉式-静态变量写法
  • 优点：简单易懂，不需要加锁。
  • 缺点：无论是否需要，都会在类加载时创建实例，可能造成资源浪费。
java 复制代码 
public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}
饿汉式-静态代码块写法
  • 实现逻辑与静态变量写法写法基本一致，优缺点同上。
java 复制代码 
public class Singleton {
    private static final Singleton INSTANCE ;

	static{
	INSTANCE  = new Singleton()
	}
    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}
懒汉式
  • 总体思想：在第一次使用时才创建实例。
懒汉式-经典写法
  • 思想：第一次使用时才创建实例。
  • 优点：可以延迟加载。
  • 缺点：在多线程环境下可能会产生多个实例，需要加锁来保证线程安全。
java 复制代码 
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {//在多线程情况下，理论上有可能出现多个线程同时进入了该判断体。
            instance = new Singleton();
        }
        return instance;
    }
}
懒汉式-同步方法（不推荐）
  • 思想：在每次调用getInstance方法时都进行同步，从而确保即使在多线程环境下，也不会创建出多个实例。
  • 优点：延迟加载、线程安全。
  • 缺点：我们知道，绝大大部分情况下资源冲突并不会频繁发生，而每次调用getInstance方法时都需要进行同步操作，这会导致性能下降。尤其是在高并发情况下，同步操作可能会成为瓶颈。
java 复制代码 
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized  Singleton getInstance() {
        if (instance == null) {//在多线程情况下，理论上有可能出现多个线程同时进入了该判断体。
            instance = new Singleton();
        }
        return instance;
    }
}
懒汉式-双重检查锁（推荐）
  • 思想：使用双重检查锁定（Double-Checked Locking），只在必要时进行同步。
  • 优点：延迟加载，并且线程安全。
  • 缺点：实现稍微复杂一些。
java 复制代码 
public class Singleton {
    private volatile static Singleton instance;//注意volatile 

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {//检查是否未初始化
            synchronized (Singleton.class) {//注意，在一个线程拿到锁后，可能有多个线程阻塞在该部分，在当前线程完成初始化操作后，他们也是有机会拿到锁的，因而需要在锁内部再加一个判断
                if (instance == null) {//为了保证其他线程对instance的可见性，instance 应该声明为volatile 
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

注意：

  • 在双重检查锁定中，instance变量需要被声明为volatile，以确保多线程环境下对instance的可见性和有序性
懒汉式-静态内部类（推荐）
  • 思想：控制类加载的时机，利用类加载机制保证初始化实例时只有一个线程。
  • 优点：既实现了懒加载，又能保证线程安全，而且代码简洁。
java 复制代码 
public class Singleton {
    private static class LazyHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}
存在的问题

简单来说，私有构造方法并不是绝对安全的，仍可通过一定方式拿到它，请看如下代码：

java 复制代码 
public static void main(String[] args) throws Exception {

        Singleton s = Singleton.getInstance();//这个Singleton可以是以上某一个
        Constructor<Singleton > constructor = Singleton .class.getDeclaredConstructor();
        constructor.setAccessible(true);//打开可访问性
        Singleton sf = constructor.newInstance();//获取其无参构造方法
        System.out.println(s == sf);//比较引用
    }

在此情况下，我们通过反射拿到了该类的一个实例，与原实例比较引用，会发现，其指向并不相同。

当然，反射问题属于比较极端的问题。但是，其在序列化和反序列化下也并不安全，假设我们的实例类实现了 Serializable接口（以上代码未实现）。

java 复制代码 
 Singleton s = Singleton.getInstance();//这个Singleton可以是以上某一个
 byte[] serialize = SerializationUtils.serialize(s);
 Object deserialize = SerializationUtils.deserialize(serialize);
 System.out.println(s == deserialize); //true or false --> false

与原实例比较引用，会发现，其指向并不相同。关于这一部分，实际上有个机制：

当一个实现了Serializable接口的单例对象被序列化后，再通过反序列化操作恢复时，默认情况下会生成一个新的对象实例。这意味着即使原始对象是单例的，反序列化后的对象也将是一个新的实例。

为了保证序列化安全，需要在单例类中定义readResolve方法。这个方法将在反序列化过程中被调用，用来返回一个替代对象。通过readResolve方法返回单例的现有实例，可以确保序列化和反序列化过程中始终只有一个实例。如：

java 复制代码 
public class Singletonimplements Serializable {

    private static class LazyHolder {
        private static final SingletonINSTANCE = new MyTest();
    }

    private Singleton() {
    }

    public static final SingletongetInstance() {
        return LazyHolder.INSTANCE;
    }

    private Object readResolve() {//see 
        return LazyHolder.INSTANCE;
    }
 }
枚举（天然适合）

事实上，枚举实现单例模式的方式是基于语言级别的支持，它不仅简洁，而且天然具备线程安全性和序列化安全性。

比如：

  • 反射安全方面：在Constructor源码中，当调用newInstance创建对象时，会检查该类是否为ENUM，如果是则抛出异常，也就是说即使拿到了该枚举类的构造方法，也无法通过反射来建立它的实例。
  • 序列化安全方面：当枚举对象被序列化时，只会将枚举常量的名字（name）输出到结果中，而不是整个对象的状态。在反序列化时，Java 会通过调用 java.lang.Enum.valueOf(Class, String) 方法来根据名字查找枚举常量，而不是创建一个新的枚举对象。。
  • 线程安全：由反编译可知，枚举常量的初始化是在静态代码块中完成的，在类加载时完成初始化，而类加载是由JVM保证线程安全的。
java 复制代码 
public enum Elvis {
    INSTANCE;

    public void leaveTheBuilding() {
        System.out.println("Elvis has left the building.");
    }
}

总结

  • 饿汉式：在类加载时创建实例，简单易懂，无需加锁。
  • 懒汉式：延迟创建实例，需考虑线程安全问题。
    • 经典写法：非线程安全。
    • 同步方法：线程安全但性能较差。
    • 双重检查锁（DCL）：线程安全且性能较好。
    • 静态内部类：线程安全且简洁。
  • 枚举：简洁且天然具备线程安全性和序列化安全性，防止反射破坏。
    好文推荐：Java 枚举实现单例模式，线程安全又优雅！
相关推荐
SkyrimCitadelValinor7 分钟前
Java【泛型】
java
java_heartLake8 分钟前
设计模式之工厂方法模式
java·设计模式·工厂方法模式
自身就是太阳24 分钟前
Maven的高级特性
java·开发语言·数据库·后端·spring·maven
飞翔的佩奇28 分钟前
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
java·数据库·spring boot·毕业设计·maven·mybatis·课程答疑
Flying_Fish_roe30 分钟前
Spring Boot-热部署问题
java·spring boot·后端
hakesashou30 分钟前
ruby和python哪个好学
开发语言·python·ruby
林一怂儿35 分钟前
H5 three.js 实现六年级观察物体
开发语言·javascript
itoshi rin39 分钟前
简单题21 - 合并两个有序链表（Java）20240917
java·数据结构·链表
NiNg_1_23444 分钟前
Python协程详解
开发语言·python
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04CANoe Trace窗口过滤栏消失的几种解决方法（附上最终解决方案）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CCF-CSP认证考试 202406-3 文本分词 100分题解