单例模式

最新推荐文章于 2025-05-23 19:33:43 发布

原创最新推荐文章于 2025-05-23 19:33:43 发布 · 156 阅读

0 ·

CC 4.0 BY-SA版权

GOF23 专栏收录该内容

1 篇文章

订阅专栏

本文深入解析单例模式的核心作用及应用场景，包括Windows任务管理器、回收站、配置文件读取等，探讨其优缺点，并详细介绍五种实现方式：饿汉式、懒汉式、双重检测锁、静态内部类及枚举单例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

核心作用：

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

常见应用场景：

1.windos系统的任务管理器

2.回收站，在整个系统运行过程中，回收站一直维护者仅有的一个实例

3.项目中，读取配置文件的，一般也只有一个对象，没有必要每次使用配置文件数据，每次去New一个对象去读取

4.网站的计数器，一般也采用单例，否则难以同步。

5.应用程序的日志应用，这是由于共享的日志文件一直处于打开状态，因此只能有一个实例去操作，否则内容不好追加

6.数据库连接池的设计一般也是采用单例模式，节省资源，因为数据库连接是一种数据库资源

7操作系统的文件系统，也是大的单例模式的例子，一个操作系统只能有一个文件系统。

8.Application也是单例的典型应用（Servlet编程中会涉及到）。

9.Spring中，每个Bean默认就是单例的，这样做的优点时Spring容器可以管理

10.Servlet编程中，每个Servlet也是单例

11.SpringMvc/Struts1框架中，控制器对象也是单例的

优点：

由于单例模式只生成一个实例，减少了系统性能的开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决

单例模式可以在系统设置全局的访问点，优化共享资源访问，例如设计一个单例类，负责所有数据表的映射处理。

常见的5种单例模式实现方法：

主要：

饿汉式（线程安全，调用效率高，但是，不能延时加载（类加载的时候即创建实例））

package com.zrrd.qsc.Singleton;

/**
 * 测试饿汉式单例
 */
public class SingletonDemo01 {

    //上来就实例化，类初始化立即加载这个对象，没有延时加载
    //天然的是线程安全的
   //垃圾回收机制是不会回收这个对象的
    private static SingletonDemo01 instance = new SingletonDemo01();

    //私有化构造方法
    private SingletonDemo01() {

    }

    //方法没有同步，调用效率高
    public static SingletonDemo01 getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        SingletonDemo01 u01=new SingletonDemo01();
        SingletonDemo01 u02=new SingletonDemo01();
        System.out.println(u01==u02);
    }
}

懒汉式（线程安全，调用效率不高，但是，可以延时加载（被调用时创建单例赋值给静态变量））

package com.zrrd.qsc.Singleton;

/**
 * 懒汉式单例测试
 * 实现延时加载
 */
public class SingletonDemo02 {

    //类初始化，不初始化这个对象，延时加载，真正用的时候再创建
    private static SingletonDemo02 instance;

    //私有化构造方法
    private SingletonDemo02() {
    }

    //synchronized实现同步,防止多个线程访问，创建多个对象，违背单例原则
    //但是调用效率低
    public static synchronized SingletonDemo02 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo02();
        }
        return instance;
    }

    public static void main(String[] args) {
        SingletonDemo02 u01=new SingletonDemo02 ();
        SingletonDemo02 u02=new SingletonDemo02 ();
        System.out.println(u01==u02);
    }
}

其他：

双重检测锁（线程安全，效率低，volatile是必须要写的，否则会出现JVM重排序的问题）


/**
 * 双重检测锁实现单例模式
 * 将同步内容放到if种，提高了效率，不用每次获取对象时都进行同步
 * 只有第一次才同步，创建了以后就不用再同步了
 *
 *问题：由于编译器优化的原因和jvm底层的原因，偶尔会出问题，不建议使用
 */
public class SingtelonDemo03 {
    private volatile static SingtelonDemo03 instance;

    private SingtelonDemo03 () {
    }

    public SingtelonDemo03 getInstance() {
        if (null == instance) {
            synchronized (SingtelonDemo03 .class) {
                if (null == instance) {
                    instance = new SingtelonDemo03 ();
                }
            }
        }
        return instance;
    }
}

静态内部类（线程安全，调用效率高，可以延时加载）

package com.zrrd.qsc.Singleton;

/**
 * 静态内部类实现单例模式
 * 线程安全，调用效率高，并实现了延时加载
 */
public class SingletonDemo04 {


    //静态内部类，并把内部类私有
    private static class SingketonClassintance{
        private static final SingletonDemo04 instance=new SingletonDemo04();
    }


    private SingletonDemo04(){}

    public static SingletonDemo04 getInstance(){
        return SingketonClassintance.instance;
    }
}

枚举单例（线程安全，调用效率高，从jvm根本上提供保障，避免通过反射和反序列化的漏洞，缺点为不能延时加载）

package com.zrrd.qsc.Singleton;

/**
 * 枚举实现单例
 * 无延时加载
 * SingletonDemo05.INSTANCE就可以直接获得对象
 */
public enum SingletonDemo05 {

    //定义了一个枚举的元素，他就代表了一个单例的实例
    INSTANCE;

    //添加自己需要的操作
    public void singletonOperation(){
        //功能处理
    }
}

选用单例模式时：

单例对象占用资源少，不需要延时加载：

枚举式好于饿汉式

单例对象占用资源大，需要延时加载：

静态内部类好于懒汉式

注：通过反射和反序列化可以破坏单例（枚举除外）