单例模式的四种写法以及与效率评测

最新推荐文章于 2025-05-21 16:31:06 发布
最新推荐文章于 2025-05-21 16:31:06 发布
阅读量248 收藏
点赞数 2
分类专栏： 设计模式 文章标签： 单例模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/WX10301075WX/article/details/121192209
版权

好久没继续了…

设计模式——单例模式

单例模式

单例模式是一种常用的软件设计模式，属于创建模式的一种。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。1

入门版

我们先看下最接地气的版本：

/**
 * 单例模式1，超简单，饿汉
 */
public class Singleton1 {
    private static final Logger logger = LoggerFactory.getLogger(Singleton1.class);
    private static final Singleton1 INTANCE = new Singleton1();

    private Singleton1() {
    }

    public static Singleton1 getInstance() {
        return INTANCE;
    }

    public static void main(String[] args) {
        LocalDateTime begin = LocalDateTime.now();
        int count = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(1);
        CountDownLatch lock = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            Thread thread = new Thread(() -> {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Singleton1 instance = Singleton1.getInstance();
                logger.info("{}", instance.hashCode());
                lock.countDown();
            }, "" + i);
            thread.start();
        }
        countDownLatch.countDown();
        try {
            lock.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("全部单例获取完毕，耗时:[{}]", Duration.between(begin, LocalDateTime.now()));
    }
}

上面的代码中通过private static final Singleton1 INTANCE = new Singleton1();就实现了单例的功能。这是利用了jvm中一个类只会被加载一次的特性。通过上面的main方法测试单例的效果会发现打印出来的单例对象的hash都是一样的。
其实这个也算是相当好的版本了，但是，有那么一丢丢的逼格不足。作为一个讲逼格的程序员，怎么能只满足到这里呢。

双重校验版

这个算是写起来比较复杂的版本：

/**
 * 单例模式2，双重校验版本
 */
public class Singleton2 {
    private static final Logger logger = LoggerFactory.getLogger(Singleton2.class);
    private static volatile Singleton2 INTANCE;

    private Singleton2() {
    }

    public static Singleton2 getInstance() {
        if (INTANCE == null) {
            synchronized (Singleton2.class) {
                if (INTANCE == null) {
                    INTANCE = new Singleton2();
                }
            }
        }
        return INTANCE;
    }

    public static void main(String[] args) {
        LocalDateTime begin = LocalDateTime.now();
        int count = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(1);
        CountDownLatch lock = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            Thread thread = new Thread(() -> {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Singleton2 instance = Singleton2.getInstance();
                logger.info("{}", instance.hashCode());
                lock.countDown();
            }, "" + i);
            thread.start();
        }
        countDownLatch.countDown();
        try {
            lock.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("全部单例获取完毕，耗时:[{}]", Duration.between(begin, LocalDateTime.now()));
    }
}

在这个版本中，使用synchronized+volatile保证在多线程情况下依旧只有一个单例。怎么说呢，属于费力不讨好的写法吧，但是对于学习多线程还是挺有帮助的

holder写法

这个写法是个人比较喜欢的一种写法，有逼格但又不复杂

/**
 * 单例模式3，holder
 */
public class Singleton3 {
    private static final Logger logger = LoggerFactory.getLogger(Singleton3.class);

    private Singleton3() {
    }

    public static Singleton3 getInstance() {
        return Singleton3Holder.INTANCE;
    }

    public static void main(String[] args) {
        LocalDateTime begin = LocalDateTime.now();
        int count = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(1);
        CountDownLatch lock = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            Thread thread = new Thread(() -> {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Singleton3 instance = Singleton3.getInstance();
                logger.info("{}", instance.hashCode());
                lock.countDown();
            }, "" + i);
            thread.start();
        }
        countDownLatch.countDown();
        try {
            lock.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("全部单例获取完毕，耗时:[{}]", Duration.between(begin, LocalDateTime.now()));
    }

    private static class Singleton3Holder {
        private static final Singleton3 INTANCE = new Singleton3();
    }
}

在holder的写法中，由于静态内部类的加载不依赖外部类，所以当Singleton3被加载时，Singleton3Holder还没有被加载，所以只要不调用Singleton3.getInstance()方法，Singleton3Holder就不会被加载，Singleton3的实例也就不会被创建，堪称典范。

神级写法

使用枚举来实现单例。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

/**
 * 单例模式4，枚举型
 */
public enum Singleton4 {

    /**
     * i'm Singleton
     */
    INTANCE;

    private static final Logger logger = LoggerFactory.getLogger(Singleton4.class);

    public static void main(String[] args) {
        LocalDateTime begin = LocalDateTime.now();
        int count = 1000;
        CountDownLatch countDownLatch = new CountDownLatch(1);
        CountDownLatch lock = new CountDownLatch(count);
        for (int i = 0; i < count; i++) {
            Thread thread = new Thread(() -> {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Singleton4 instance = Singleton4.INTANCE;
                logger.info("{}", instance.hashCode());
                lock.countDown();
            }, "" + i);
            thread.start();
        }
        countDownLatch.countDown();
        try {
            lock.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("全部单例获取完毕，耗时:[{}]", Duration.between(begin, LocalDateTime.now()));
    }
}

总结

不管哪种写法，第一步都得是保证构造器私有，不然的话，就没法单例了。真要说绝对单例，那只有通过枚举实现的单例能实现绝对单例。因为枚举类是没有构造方法的，别人就算通过映射的方式，也无法创建第二个实例。除了枚举这种方式之外的所有方式都可以通过反射的方式被人创建多例。但是，谁会这么欠儿欠儿的呢…

效率评测

剧透一下：效率上基本没区别，大家可以放心使用，详情见：压力测试-Benchmark_wx的博客-优快云博客

  1. 维基百科中关于单例模式的说明 ↩︎

算法与数据结构高频面试题
悦分享
06-17 261
就是我们常见的：购买该商品的用户还购买了如下商品，等等就是文章开头前的啤酒和纸尿裤的故事，因为超市的人员发现很多男人买纸尿裤的时候会买啤酒，根据这一用户行为，纸尿裤和啤酒的相似度较高，那么在用户购买纸尿裤的时候推荐啤酒，增加啤酒的销量。当然，举的这个例子十分简单，实际上，还需要考虑的是每个用户物品的偏好程度，虽然用户 A 和用户 C 都玩过英雄联盟，但是用户 A 和用户 C 对英雄联盟的偏好程度可能不一样，在真正的计算过程中，需要对这种偏好的程度设定一个参数，参数的大小表明用户对物品的偏好程度的大小。
java从入门到精通API02
cgblpx的博客
02-09 2857
文章目录1 多线程11.1 进程1.1.1 概念1.1.2 特点1.2 线程1.2.1 概念1.2.2 进程和线程的关系1.3 多线程的特性1.3.1 随机性1.3.2 线程状态![在这里插入图片描述](https://img-blog.csdnimg.cn/81eeac448385475a9856ed7acd95ab35.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAY2dibHB4,size_20
Java设计模式（二）：单例模式的5种实现方式，以及在多线程环境下5种创建单例模式的效率
Happy in Code
05-23 2180
这段时间从头温习设计模式。记载下来，以便自己复习，也分享给大家。 package com.iter.devbox.singleton; /** * 饿汉式 * @author Shearer * */ public class SingletonDemo1 { // 类的静态成员变量只初始化一次，天然是线程安全的 private static final Singlet
五种单例模式的效率问题
hank之路
02-26 1538
谈到效率，当然要使用多线程！5个单例设计模式同时创建1亿个单例的耗时。
java学习笔记-设计模式之五种单例模式实现效率测试
学渣程序员的博客
11-24 282
在前两天的学习中主要对单例模式完成了五种实现，并针对反射及反序列化漏洞进行防止，最后对五种实现模式的效率进行测试。 五种最终实现单例模式代码如下： 1、懒汉式实现单例模式： package com.zwh.gof23.singleton; import java.io.Serializable; /** * 懒汉式到单例模式(防序列化及反射漏洞) * @author zwh * ...
五种常见的单例模式及其效率测试
BigCabbageFy的博客
04-01 2671
所谓单例模式就是不管你此时new多少新对象，它只会创建出一个对象供你使用。 最基础的两种单例模式是：饿汉式和懒汉式。 而还有三种常见的单例模式：双重检测锁模式、静态内部类实现和枚举类实现模式。 懒汉式： /** * 测试懒汉式单例模式 * 延时加载，用到了才创建对象，提高了资源的利用率。 * 但由于需要用到同步，导致并发效率很低。 ...
设计模式之———单例模式的问题及效率比较
lyyao09的博客
09-29 1722
目录 - 出现问题 - 问题展示及解决方法 - 不同单例模式的效率比较
项目上线一年，整理了一份SpringBoot性能优化方案！
m0_73257876的博客
09-22 876
SpringBoot已经成为Java届的No.1框架，每天都在蹂躏着数百万的程序员们。当服务的压力上升，对SpringBoot服务的优化就会被提上议程。本文将详细讲解SpringBoot服务优化的一般思路，并附上若干篇辅助文章作为开胃菜。1.有监控才有方向在开始对SpringBoot服务进行性能优化之前，我们需要做一些准备，把SpringBoot服务的一些数据暴露出来。比如，你的服务用到了缓存，就需要把缓存命中率这些数据进行收集；用到了数据库连接池，就需要把连接池的参数给暴露出来。
python 基础知识
kgditxl的博客
05-19 1527
前言 推荐使用Typora解锁全套，下载地址：https://www.typora.io/ Markdown是一种可以使用普通文本编辑器编写的标记语言，通过简单的标记语法，它可以使普通文本内容具有一定的格式。 使用word撰写文档，有如下的弊端： 只能对纯文本文件进行版本控制，而word是二进制格式 格式繁杂，经常需要中断写作来控制格式 代码与文档分离，给写文档造成更大的阻力 而假如单纯的使用txt，就没有一点格式了， 用html虽然既有格式又能加入版本控制，但是需要花费较多的时间在
BlogTest1
zz_itheima的博客
12-12 404
常见数据结构题 SparseArray SparseBooleanArray = HashMap 常见设计模式 单例Builder观察者工厂代理适配器 3种常见的单例写法 饿汉式（静态常量）[可用] public class Singleton { private final static Singleton INSTANCE = new
各种单例模式的效率测试及实际运用（原）
JavaTeachers的博客
08-22 464
单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。 懒汉式单例模式： package Dao.xxlDao; /** * @BelongsPackage:Dao.xxlDao * @Author:Administrator * @CreateTime:2019-08-20 15:34 * @De...
详解单例模式及性能比较
yozzs的博客
10-24 1325
单例模式是java中广泛运用的一种设计模式。单例模式的基本原则是一个类对外只提供一个实例，单例对象只会被初始化一次。 实现单例的基本思想是构造函数私有化，自己构造一个实例，对外暴露实例的get方法。它的写法多种多样，下面就介绍单例模式的饿汉式、懒汉式、双重检测锁、静态内部类、枚举这5种写法。并从线程安全、反射漏洞、反序列化漏洞三个方面进行分析优化。最后测试各写法的性能。 一、单例的5种写法 饿汉式...
通过double-check解决单例模式效率低的问题
NC_star的博客
08-19 687
    单例模式的应用场景是在一个项目系统运行的过程中某一个类只被创建一次，也就是说只允许一个该类的一个对象存在。其实如果想实现这种目的有很多方法，这里我之所以提及是因为我之前在使用单例模式的时候没有注意到我的单例模式代码还有提高效率的空间，接下来将把我之前实现单例模式的代码和通过改进的代码列举出来，通过对比指出之前的不足。 1）之前使用的单例模式，示例代码如下：   2）经过改进后的单...
（一）单例模式之不同写法的性能比较
QingFeng-Li的博客
08-23 743
简介 ： 设计模式是前人工作的总结和提炼，通常，被人们广泛流传的设计模式都是对某一特定问题的成熟的解决方案。如果能合理的使用设计模式，不仅能使系统更容易被他人理解，同时也能使系统拥有更加合理的结构。 单例模式 单例模式是设计模式之中使用最为普遍的设计模式之一，它是一种对象创建模式，用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例，在java中这样的行为能带来两个好处： 对于...
设计模式系列（04）：单例模式（Singleton）
05-20 1112
单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。
Unity序列化字段、单例模式(Singleton Pattern)
2401_83210138的博客
05-17 957
在Unity中，序列化字段和单例模式是两个重要的概念。序列化字段通过[SerializeField]属性允许私有或受保护的字段在Unity编辑器的Inspector窗口中显示和编辑，同时支持对象状态的保存和加载。默认情况下，公共字段会被序列化，而私有字段、静态字段和只读字段则不会。序列化字段适用于组件属性编辑、游戏状态保存与加载以及网络同步等场景。单例模式则确保类在程序运行期间只有一个实例，并提供全局访问点。单例模式分为饿汉式和懒汉式，饿汉式在类加载时立即创建实例，适合核心功能；懒汉式在首次访问时创建实例，
零基础设计模式——创建型模式 - 单例模式
qqxhb 资源共享
05-20 1069
单例模式是一种创建型设计模式，旨在确保一个类仅有一个实例，并提供一个全局访问点。其核心思想在于将对象的创建与使用分离，降低系统耦合度。单例模式适用于需要全局唯一实例的场景，如数据库连接池、配置管理器、日志记录器等。实现方式主要分为“饿汉式”和“懒汉式”：饿汉式在类加载时即创建实例，线程安全；懒汉式则在首次请求时创建实例，需处理多线程安全问题。单例模式的优点包括保证实例唯一、全局访问和延迟实例化，但也存在违反单一职责原则、扩展困难、测试不友好等缺点。通过合理使用单例模式，可以有效管理全局资源和状态，但需避免滥
【C/C++】探索单例模式：线程安全与性能优化
最新发布
YZJincsdn的博客
05-21 1081
增加锁，用于保证线程安全，但是锁开销会影响性能。c++机制保证初始化安全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值