设计模式 —— 单例模式

最新推荐文章于 2022-06-14 00:26:02 发布
最新推荐文章于 2022-06-14 00:26:02 发布
阅读量589 收藏 8
点赞数 5
分类专栏： 设计模式 文章标签： 设计模式
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/weixin_32265569/article/details/108267837
版权

目录

一、什么是单例设计模式？

二、单例设计模式实现形式

1、饿汉式实现方式一（推荐）

2、饿汉式实现方式二

3、懒汉式实现方式一（线程不安全）

4、懒汉式实现方式二（线程安全，但效率低）

5、懒汉实现方式三（线程不安全）

6、懒汉实现方式四 - DCL 双端检查 + volatile（线程安全）

7、静态内部类方式，JVM 保证单例（推荐）

8、通过枚举实现单例模式（不推荐）

一、什么是单例设计模式？

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

类结构图

具体实现

  1. 将构造方法私有化，使其不能在类的外部通过 new关键字实例化该类对象。
  2. 在该类内部产生一个唯一的实例化对象，并且将其封装为 private static 类型。
  3. 定义一个静态方法返回这个唯一对象。

二、单例设计模式实现形式

饿汉式，从名字上也很好理解，就是“比较勤”，实例在初始化的时候就已经建好了，不管你有没有用到，都先建好了再说。好处是没有线程安全的问题，坏处是浪费内存空间。

懒汉式，顾名思义就是实例在用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则返回，没有则新建。有新线程安全和线程不安全两种写法，区别就是 Synchronized 关键字。

1、饿汉式实现方式一（推荐）

类加载到内存后，就实例化一个单例，JVM保证线程安全；简单使用；

但也有缺点：不管用到与否，类装载时就完成实例化

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * Class.forName("")
 * （话说你不用的，你装载它干啥）
 */
public class Singleton_01 {

    private static final Singleton_01 INSTANCE = new Singleton_01();

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

    public static Singleton_01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Singleton_01 singleton01 = Singleton_01.getInstance();
        Singleton_01 singleton02 = Singleton_01.getInstance();

        System.out.println(singleton01 == singleton02);
    }
}

2、饿汉式实现方式二

与上述 Singleton_01 一样，通过静态代码块实现单例的实例化

/**
 * 跟01是一个意思
 */
public class Singleton_02 {

    private static final Singleton_02 INSTANCE;

    // 通过静态代码块实现单例的实例化
    static {
        INSTANCE = new Singleton_02();
    }

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

    public static Singleton_02 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Singleton_02 singleton01 = Singleton_02.getInstance();
        Singleton_02 singleton02 = Singleton_02.getInstance();

        System.out.println(singleton01 == singleton02);
    }

}

3、懒汉式实现方式一（线程不安全）

懒汉式即需要使用类的实例化时才创建对象，但下述懒汉式却带来了线程不安全的问题；通过使用多线程也获取单例对象的 hashCode 非常容易拿到不一样的hashCode，证明单例对象不是同一个，即存在线程不安全问题。

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 */
public class Singleton_03 {

    private static Singleton_03 INSTANCE;

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

    public static Singleton_03 getInstance() {
        if (INSTANCE == null) {
            try {
                TimeUnit.MILLISECONDS.sleep(1);
            } catch (Exception e){
                e.printStackTrace();
            }
            INSTANCE = new Singleton_03();
        }

        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton_03.getInstance().hashCode());
            }).start();

        }
    }
}

4、懒汉式实现方式二（线程安全，但效率低）

运行过 【懒汉式实现方式一】就会发现存在多线程不安全的问题，因为可以引入 Synchronized 同步方法来解决此问题，但却带来了效率下降问题。

补充说明下：Synchronized在这里是修饰静态同步方法，实际上是对该类 Class 对象加锁，俗称“类锁”。

关于: Sychronized 关键字的知识，可参考：Java 并发 —— Synchronized 关键字和锁升级 【可下载 Synchronized_思维导图】

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 线程当安全的问题，可以通过 synchronized 解决，但也带来效率下降
 */
public class Singleton_04 {
    private static Singleton_04 INSTANCE;

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

    // 锁住 Singleton_04 对象
    public static synchronized Singleton_04 getInstance() {
        if (INSTANCE == null) {
            try {
                TimeUnit.MILLISECONDS.sleep(1);
            } catch (Exception e){
                e.printStackTrace();
            }
            INSTANCE = new Singleton_04();
        }

        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton_04.getInstance().hashCode());
            }).start();

        }
    }
}

5、懒汉实现方式三（线程不安全）

运行过 【懒汉式实现方式二】就会发现引入 Synchronized 同步方法来解决多线程不安全问题，但却带来了效率下降问题。为此，将 Synchronized 同步锁的粒度减小，发现效率是提升了，但依然没有解决多线程不安全问题

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过 synchronized 解决，但也带来效率下降
 * 通过减少 synchronized 同步锁粒度，发现多线程不安全问题依然存在
 */
public class Singleton_05 {
    private static Singleton_05 INSTANCE;

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


    public static Singleton_05 getInstance() {
        if (INSTANCE == null) {
            // 妄图通过减少同步代码块的方式提高效率，然后不可能
            synchronized (Singleton_05.class) {
                try {
                    TimeUnit.MILLISECONDS.sleep(1);
                } catch (Exception e){
                    e.printStackTrace();
                }
                INSTANCE = new Singleton_05();
            }

        }

        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton_05.getInstance().hashCode());
            }).start();
        }
    }
}

6、懒汉实现方式四 - DCL 双端检查 + volatile（线程安全）

减少 synchronize 效率是可以的，但依然存在多线程不安全问题；通过引入 DCL （Double Check Lock 双端检查方式） + volatile （禁止指令重排），解决了多线程安全问题，同时还提高了效率。

关于volatile 的知识，可参考：请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”

DCL + Volatile，综合了懒汉式和饿汉式两者的优缺点整合而成。看下面代码实现中，特点是在 Synchronized 关键字内外都加了一层 if 条件判断，这样既保证了线程安全，又比直接上锁提高了执行效率，还节省了内存空间。在这里使用 volatile 会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。DCL 优点是资源利用率高，第一次执行 getInstance() 时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是它还是在某些情况会出现失效的问题，也就是DCL 失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL.

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过 synchronized 解决，但也带来效率下降
 * 通过减少 synchronized 同步锁粒度，发现多线程不安全问题依然存在
 * 通过采用 DCL 即 Double Check Lock 双端检查机制，出现多线程不安全问题概率大大降低了，但还有存在多线程不安全问题
 */
public class Singleton_06 {
    private static volatile Singleton_06 INSTANCE;

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


    public static Singleton_06 getInstance() {
        if (INSTANCE == null) {
            // 双重检查
            synchronized (Singleton_06.class) {
                if (INSTANCE == null) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(1);
                    } catch (Exception e){
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton_06();
                }
            }

        }

        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton_06.getInstance().hashCode());
            }).start();
        }
    }
}

7、静态内部类方式，JVM 保证单例（推荐）

通过 JVM 加载外部类时不会加载内部类，这样可以实现懒加载，完美写法之一，比第一种要好一些
第一次加载 Singleton 类时并不会初始化 INSTANCE，只有第一次调用 getInstance 方法时虚拟机加载 Singleton_07_Holder 并初始化 INSTANCE，这样不仅能确保线程安全也能保证 Singleton 类的唯一性，所以推荐使用静态内部类单例模式。

/**
 * 静态内部类方式
 * JVM 保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 *
 * 完美写法之一，比第一种要好一些
 */
public class Singleton_07 {

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

    private static class Singleton_07_Holder {
        private final static Singleton_07 INSTANCE = new Singleton_07();
    }

    // 不但实现了懒加载，而且只加载一次
    // Singleton_07如果实例化了，Singleton_07_Holder也不会实例化，只有在getInstance被调用时才加载
    public static Singleton_07 getInstance() {
        return Singleton_07_Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton_07.getInstance().hashCode());
            }).start();
        }
    }
}

8、通过枚举实现单例模式（不推荐）

枚举的方式是比较少见的一种实现方式，但是看上面的代码实现，却更简洁清晰。不仅可以解决线程同步，还可以防止反序列化.

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例，上述讲的几种单例模式实现在，有一种情况下他们会重新创建对象，那就是反序化，将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了 readResolve 方法，这个方法可以让开发人员控制对象的反序列化。在上述几个方法示例中如果要杜绝单例对象被反序列化是重新生成对象。

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

/**
 * 不仅可以解决线程同步，还可以防止反序列化
 */
public enum Singleton_08 {

    INSTANCE;

    public void m() {}

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Singleton_08.INSTANCE.hashCode());
            }).start();
        }
    }
}

总结：

上述8种写法，至于在实际项目中选择哪种形式的单例模式，取决于你的项目本身，是否有复杂的并发环境，还是需要控制单例对象的资源消耗。

 

文章最后，给大家推荐一些受欢迎的技术博客链接：

  1. JAVA相关的深度技术博客链接
  2. Flink 相关技术博客链接
  3. Spark 核心技术链接
  4. 设计模式 —— 深度技术博客链接
  5. 机器学习 —— 深度技术博客链接
  6. Hadoop相关技术博客链接
  7. 超全干货--Flink思维导图，花了3周左右编写、校对
  8. 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
  9. 请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”
  10. 聊聊RPC通信，经常被问到的一道面试题。源码+笔记，包懂
  11. 深入聊聊Java 垃圾回收机制【附原理图及调优方法】

欢迎扫描下方的二维码或 搜索 公众号“大数据高级架构师”，我们会有更多、且及时的资料推送给您，欢迎多多交流！

                                           

       

 

不埋雷的探长
关注
专栏目录
JAVA 枚举单例模式及源码分析的实例详解
08-29
主要介绍了 JAVA 枚举单例模式及源码分析的实例详解的相关资料,需要的朋友可以参考下
单例模式-设计模式
FiveCode的博客
09-30 156
​ 老韩讲解过程中，统计本机cpu数目时，提到了单例。 单例模式是一种设计的模式，因为很多东西在整个应用的过程中只需要一个全局的对象。不需要多个，例如重复点击回收站，返回的是同一个对象，没有必要创建多个对象。 优点： 在内存中只有一个对象，节省内存空间； 避免频繁的创建销毁对象，可以提高性能； 避免对共享资源的多重占用，简化访问； 为整个系统提供一个全局访问点。 缺点：1.不适用于变化频繁的对象 ？因为频繁变化的对象在一般过程中可以通过上一层进行功能的拓展。但是对于单例模式...
什么是单例设计模式？
qq_40220357的博客
05-13 1859
什么是单例设计模式？ 单例模式，是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例 优点 一、实例控制 单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。 二、灵活性 因为类控制了实例化过程，所以类可以灵活更改实例化过程。 缺点 一、开销 虽然数量很少，但如...
设计模式之——单例模式你真的会吗？
诸葛小猿
08-06 1797
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。简单说，模
java设计模式之单例模式（枚举、静态内部类、ThreadLocal）
weixin_33804990的博客
05-14 381
2019独角兽企业重金招聘Python工程师标准>>> ...
java设计模式——单例模式
12-22
【Java设计模式——单例模式】 单例模式是一种常见的软件设计模式，它的核心思想是确保在应用程序的整个生命周期中，某个类只有一个实例存在。这种模式主要用于控制类的实例化过程，减少系统资源的消耗，提高系统...
设计模式——单例模式
08-11
**设计模式——单例模式** 在软件工程中，设计模式是一种在特定场景下解决常见问题的标准方案，可以被复用并提升代码质量。单例模式是设计模式中的一种，它保证一个类只有一个实例，并提供一个全局访问点。这种模式...
C++设计模式——单例模式-附件资源
03-05
C++设计模式——单例模式-附件资源
设计模式——单例模式（懒汉模式）
08-10
单例模式是软件设计模式中的一种经典模式，它保证了类在任何情况下都只有一个实例存在。这个模式在很多场景下非常有用，例如控制全局资源、管理配置信息等。本文将详细探讨单例模式的懒汉式实现，并结合源码进行解析...
单例设计模式源码分析，常用设计模式白话文总结
weixin_33980459的博客
05-31 240
2019独角兽企业重金招聘Python工程师标准>>> ...
单例模式-23种设计模式系列
nntcdhl的博客
05-04 244
什么是单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例...
单例模式源码分析(jdk+spring+mybatis)
Leon_Jinhai_Sun的博客
06-03 430
我们首先看一个简单的,Runtime这个类在java.lang下的,我们看一下getRuntime() public static Runtime getRuntime() { return currentRuntime; } 可以看到这里直接返回一个currentRuntime private static Runtime currentRuntime = new Runtime();...
单例模式示例与解析
HD243608836的博客
07-12 492
写一个单例模式出来（代码）： 饿汉模式 public class Single { //私有本类中的构造函数 private Single(){} //创建本类对象 private static Single s = new Single(); //对外提供获取本来对象方法 public static Single getInstance(){ return s; } } ...
单例模式详解（附代码和源码分析）-饿汉式，懒汉式，序列化破坏单例，枚举单例等多种写法
黄金时代的架构之路
03-13 538
单例模式 ​ 保证一个类在任何情况下都绝对只有一个实例，并且提供一个全局访问点 ​ 需要隐藏其所有构造方法 ​ 优点： ​ 在内存中只有一个实例，减少了内存开销 ​ 可以避免对资源的多重占用 ​ 设置全局访问点，严格控制访问 ​ 缺点： ​ 没有接口，扩展困难 ​ 如果要扩展单例对象，只有修改代码，没有别的途径 应用场景 ​ ServletContext ​ ServletConfig ...
单例模式 代码以及祥解
weixin_34137799的博客
08-06 135
单例模式的 本质： 　　控制实例数目 定义： 　　保证一个类仅有一个实例，并提供一个它的全局访问点。 　　单例模式有两种实现方式：饿汉模式和懒汉模式。 懒汉式实现代码： public class Singleton{ 　　private static Singleton uniqueInstance = null; 　　privateSingleton(){} 　　priva...
【深入设计模式】单例模式—从源码分析内部类单例、枚举单例以及单例模式在框架中的应用
SK_Jaco的博客
06-14 590
最完美的单例写法以及单例模式在源码中的应用
【Java】浅析单例模式（六种单例模式的代码实现及详解）
weixin_44836685的博客
07-20 528
一、单例模式概述 单例模式是一种常用的设计模式，也被称作单子模式。再用这个模式的时候，必须保证有且只有一个实例存在。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。避免一个通信端口同时被两个请求调用，用单例模式就可以避免这种不一致状态。 单例模式特点： 1、私有化类的构造函数，不能再让用户通过new的方法随意的产生对象 2、单例需要给类提供唯一一个单例对象...
设计模式-单例模式(代码分析+例子)
KX興博客
12-03 412
设计模式-单例模式 文章目录设计模式-单例模式一 单例模式介绍二 实现单例模式主要关键点三 单例模式实现方式1. 懒汉模式(个人理解:懒,就是调用时候再new)2. 饿汉模式(个人理解:饿,new好,直接获取)四 Double Check Lock-DCL(双重锁定机制)实现单例,不赞成使用点一 两次判空点二 DCL乱序处理之volatileDCL优缺点五 静态内部类单例模式(推荐使用)六 单例总...
设计模式之单例模式完全解析
gongxiaoou的博客
03-24 645
概述在Android开发中我们对别的设计模式可能不了解或没见过，但是单例模式你是绝对见过或者写过的。但是在写的人里面有的真的了解单例模式而有的则是一知半解，那就造成了可能你写的单例带来的好处大于坏处，更或者坏处大于好处只是自己没有发现。 今天我就我目前的理解来谈一谈单例模式，帮助我们更好的来利用单例模式。（在java和Android的基础之上）一.单例模式简介1.1 概念Singleton 模式可
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不埋雷的探长

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值