设计模式之单例模式(Singleton)

最新推荐文章于 2023-06-19 17:17:49 发布
最新推荐文章于 2023-06-19 17:17:49 发布
阅读量1.9w 收藏 3
点赞数 1
分类专栏： 设计模式 Java 文章标签： java 设计模式 多线程 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_Java_Dog/article/details/117432015
版权

设计模式之单例模式

设计模式之单例模式

应用场景

适用场景

适用场景：
单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。如：
11.需要频繁实例化然后销毁的对象。
2.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
3.有状态的工具类对象。
4.频繁访问数据库或文件的对象。
以下都是单例模式的经典使用场景：
1.资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。
2.控制资源的情况下，方便资源之间的互相通信。如线程池等。

实际应用

  • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

  • 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

java之外的应用
windows的任务管理器和回收站

01 饿汉式

这也是最常用的一种方式，它是线程安全的，它依靠JVM来实现线程安全，因为JVM加载一个class，只会加载一次。

package com.cyc.design.singleton;

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

    private static final Singleton01 INSTANCE = new Singleton01();

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton01() {
    }

    public static Singleton01 getInstance() {
        return INSTANCE;
    }

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

    public static void main(String[] args) {
        Singleton01 instance1 = Singleton01.getInstance();
        Singleton01 instance2 = Singleton01.getInstance();
        //获取到的两个示例进行比较，如果不是一个实例，则会是false，是一个实例则为true
        System.out.println(instance1 == instance2);
    }
    
}

查看结果

在这里插入图片描述

02 另一种饿汉式

package com.cyc.design.singleton;

/**
 * @author chenyunchang
 * @version 1.0
 * @date 2021/6/1 10:06
 * 饿汉式 第二种写法，这种是在静态代码块里进行实例化
 */
public class Singleton02 {

    private static final Singleton02 INSTANCE ;

    static {
        INSTANCE = new Singleton02();
    }

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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton02() {
    }

    public static Singleton02 getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Singleton02 instance1 = Singleton02.getInstance();
        Singleton02 instance2 = Singleton02.getInstance();
        //获取到的两个示例进行比较，如果不是一个实例，则会是false，是一个实例则为true
        System.out.println(instance1 == instance2);
    }

}

查看结果

在这里插入图片描述

03 懒汉式

package com.cyc.design.singleton;

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

    private static Singleton03 INSTANCE;


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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton03() {
    }

    public static Singleton03 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        Singleton03 instance1 = Singleton03.getInstance();
        Singleton03 instance2 = Singleton03.getInstance();
        //获取到的两个示例进行比较，如果不是一个实例，则会是false，是一个实例则为true
        System.out.println(instance1 == instance2);
    }

}

线程安全问题

  • 懒汉式虽然达到了按需加载的目的， 但是却带来了线程安全的问题，当多个线程进入到判断INSTANCE == null时，可能会出现两个线程都new了一个对象，此时，便破坏了单例模式，JVM出现了两个此对象的实例，后续的业务中可能会出现由于线程不安全带来的其他问题。

    事例如下

    package com.cyc.design.singleton;

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

    private static Singleton03 INSTANCE;


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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton03() {
    }

    public static Singleton03 getInstance() {
        if (INSTANCE == null) {
            try {
                //这里让进入此代码块的线程睡一毫秒
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton03();
        }
        return INSTANCE;
    }

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

}

    查看结果

    可以看到，获取到对象的hashcode并不相同，所以，并不是一个对象，因此懒汉式在多线程环境下，会有线程安全问题

在这里插入图片描述

04 优化懒汉式 -保证线程安全

通过在获取实例的方法上加锁

package com.cyc.design.singleton;

/**
 * @author chenyunchang
 * @version 1.0
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Singleton04 {

    //volatile关键字禁止指令重排
    private static volatile Singleton04 INSTANCE;


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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton04() {
    }

    /**
     * 添加synchronized锁，保证只有一个线程能进入该方法
     * 每次getInstance之前，去判断此方法是否已加锁，是：则等待锁释放，否：则去尝试获取锁，并加锁。
     * 由于多了获取锁，释放锁的步骤，因此降低了很多执行效率，但是却是线程安全的
     * @return
     */
    public static synchronized Singleton04 getInstance() {
        if (INSTANCE == null) {
            try {
                //这里让进入此代码块的线程睡一毫秒
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton04();
        }
        return INSTANCE;
    }

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

}

查看结果

在这里插入图片描述

05 优化懒汉式-提升执行效率（反例）

package com.cyc.design.singleton;

/**
 * @author chenyunchang
 * @version 1.0
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Singleton05 {

    //volatile关键字禁止指令重排
    private static volatile Singleton05 INSTANCE;


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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton05() {
    }
    
    public static Singleton05 getInstance() {
        if (INSTANCE == null) {
            //妄图通过减小同步代码块的方式提高效率，然后不可行
            synchronized (Singleton05.class) {
                try {
                    //这里让进入此代码块的线程睡一毫秒
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Singleton05();
            }
        }
        return INSTANCE;
    }

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

}

查看结果

在这里插入图片描述

06 优化懒汉式-提升执行效率

package com.cyc.design.singleton;

/**
 * @author chenyunchang
 * @version 1.0
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Singleton06 {

    //volatile关键字禁止指令重排
    private static volatile Singleton06 INSTANCE;


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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton06() {
    }

    public static Singleton06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Singleton06.class) {
                if (INSTANCE == null) {
                    try {
                        //这里让进入此代码块的线程睡一毫秒
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton06();
                }
            }
        }
        return INSTANCE;
    }

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

}

查看结果

在这里插入图片描述

为什么要加volatile？

为了防止指令重排。这里涉及到类的加载过程。

首先，第一个线程进来了， 加上锁之后，进入到INSTANCE = new Singleton06();代码，在初始化进行到一半的时候，也就是在preparation阶段，已经给Singleton06申请完内存，里面的成员变量已经赋过默认值，比如0，此时INSTANCE 已经指向这个分配的内存， 已经不再是null，此时另外一个线程进来了，由于此时INSTANCE 已经进行了半初始化状态，所以在if (INSTANCE == null)为false，此时另一个线程会拿到这个INSTANCE中的成员变量进行操作， 这样显然是不满足要求的。

想要解析这个问题， 需要查看其字节码文件

例如下面这个测试类T， 使用idea插件查看其字节码文件

在这里插入图片描述

在0 new #2 <com/cyc/jvm/c0_basic/T>之后，已经申请过内存。

4 invokespecial #3 <com/cyc/jvm/c0_basic/T.> 这个给类中的静态变量赋初始值

在调用完4之后，才会把这块内存赋值给t，但是由于指令可能会重排的原因， 如果先执行的是7 astore_1, 相当于先把这个地址扔到内存中, 然后在进行的T初始化, 这种情况下，在双重检查懒汉式单例中，就会出现有别的线程读取到半初始化的单例。

07 静态内部类方式

类被加载的时候，内部类并不会被加载。
虚拟机加载一个class的时候，只加载一次，它的内部类也只加载一次，所以从始至终就只有一个instance，所以线程安全

package com.cyc.design.singleton;

/**
 * @author chenyunchang
 * @version 1.0
 * lazy loading
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class Singleton07 {

    private static class Singleton07Holder {
        private static final Singleton07 INSTANCE = new Singleton07();
    }

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

    /**
     * 构造方法为私有，只能在当前类中new，外部类无法new出来
     */
    private Singleton07() {
    }

    public static Singleton07 getInstance() {
        return Singleton07Holder.INSTANCE;
    }

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

}

查看结果

在这里插入图片描述

08 使用枚举类

《Effective Java》 作者给出了一种完美的单例模式，即使用枚举类，枚举类型的单例天生线程安全，

我们定义的一个枚举，在第一次被真正用到的时候，会被虚拟机加载并初始化，而这个初始化过程是线程安全的。而我们知道，解决单例的并发问题，主要解决的就是初始化过程中的线程安全问题。

所以，由于枚举的以上特性，枚举实现的单例是天生线程安全的。

在这里插入图片描述

查看结果

在这里插入图片描述

意田天
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
php设计模式 Singleton(单例模式)
12-19
php /** * 单例模式 * * 保证一个类仅有一个实例,并提供一个访问它的全局访问点 * */ class Singleton { static private $_instance = null; private function __construct() { } static public function ...
单例模式
深水流静
11-24 179
文章目录一、定义二、Java实现2.1、饿汉式（静态常量）[可用]2.2、饿汉式（静态代码块）[可用]2.3、懒汉式(线程不安全)[不可用]2.4、懒汉式(线程安全，同步方法)[不推荐用]2.5、懒汉式(线程安全，同步代码块)[不可用]2.6、双重检查[推荐用]2.7、静态内部类[推荐用]2.8、枚举[推荐用] 一、定义 单例模式（Singleton Pattern）是 Java 中最简单的设计模...
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 98万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 3759
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
设计模式之——单例模式
最新发布
很高兴你能看到这里
06-19 2242
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
设计模式之单例模式（通俗易懂，超详细）
良猿啊
07-15 2404
1 什么是单例模式 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例） ——《百度百科》 简单来说单例模式就是指在内存中只会创建且仅创建一次对象的设计模式，当程序中其他地方需要使用到该对象的相同功能时，都会调用创建好的这一个，不会再额外创建实例，这样做的好处就是避免过多的创建相同作用的对象使得内存浪费。 2 单例模式分类 在单例模式中主要分为两类，分别是懒汉式和饿汉式 懒汉式：在程
研磨设计模式之单例模式
02-27
 单例模式（Singleton）1 场景问题1.1 读取配置文件的内容考虑这样一个应用，读取配置文件的内容。很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的...
JavaScript设计模式之单例模式详解
12-11
这一次重温一下《JavaScript设计模式与开发实践》，开篇为单例模式。 /** * pre 单例模式 * 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点 * 应用：单例模式是一种常用的模式，有一些对象我们...
PHP设计模式之单例模式定义与用法分析
01-03
单例模式（Singleton Pattern 单件模式或单元素模式），是常见的一种设计模式，它有三个特点 1．只能有一个实例 2．必须自行创建这个实例 3．必须给其他对象提供这一实例 下面用PHP代码实现一下 <?PHP /** *...
大话设计模式--Singleton(单例模式)
03-28
NULL 博文链接：https://linxingliang.iteye.com/blog/1217811
单例模式的优缺点和使用场景
Will_hua的博客
01-13 3475
单例模式的优缺点和使用场景 文章转自:http://www.tools138.com/create/article/20150929/020009847.html 单例模式的优缺点和使用场景 - 晓明的哥哥 - 博客园 单利模式的优缺点和使用场景 首先介绍一下单例模式： 单例模式（Singleton），也叫单子模式，是一种常用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程...
【设计模式】单例模式
小鼠标的博客
03-25 601
单例模式作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。一。简解单例模式很好理解，拆看单，单一的；例，实例。合起来，单一的实例，哈哈，很简单吧，就是真个系统中只能出现某个类的一个实例，这就是单例模式。二。用途三。实例饿汉式/** * 单例模式懒汉方式实现 */ public class EagerSingleton { pr
设计模式——单例模式
qq_51114283的博客
07-11 2185
创建型模式——单例模式
单例对象会被jvm的gc时回收吗_1.单例模式
weixin_39775029的博客
12-08 392
点击上方蓝字,关注并星标,和我一起学技术.什么是单例模式？单例模式非常常见，当您想控制实例数目，节省系统资源的时候，保证一个类仅有一个实例，并提供一个访问它的全局访问点，就可以使用单例模式。单例最关键的是构造函数是私有的。应用实例：一个班级只有一个班主任。Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通...
【Linux】浅析单例模式与线程池
Catdeo的博客
09-29 239
单例模式及其应用场景 单例模式是一种常见的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局对象，这样有利于协调系统整体的行为。例如在服务器程序中，该服务器的配置信息存放在一个文件中，这些配置信息由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这样能够简化复杂环境下的配置管理。 如何实现一个单例模式 一个类能...
设计模式系列教程（04） - 单例模式
阿甘兄
10-28 542
代码已上传至Github，有兴趣的同学可以下载来看看：https://github.com/ylw-github/Java-DesignMode 1. 什么是单例 保证一个类只有一个实例，并且提供一个访问该全局访问点 2.单例应用场景 Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manage...
单例模式创建线程池-ThreadPool
try
11-14 6257
单例模式：一个类有且仅有一个实例，并且自行实例化向整个系统提供。 单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。 单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象
JAVA单例模式（用于表示 线程池、数据库连接池、打印池等系统唯一性资源）
weixin_37136725的博客
12-19 2738
什么是单例类？ 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。 单例类的应用场景？ 　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打
设计模式之单例双重其锁
04-18
好的，这是一个关于设计模式的技术问题，我可以为您解答。 单例双重锁模式是一种常用的线程安全的单例模式实现方式。其核心思想是在getInstance()方法中使用双重判断锁，即先判断实例是否已经被创建，如果没有被...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

意田天

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

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

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

打赏作者

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

抵扣说明：

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

余额充值