23种设计模式-单例模式

已于 2023-04-12 13:36:34 修改
阅读量146 收藏
点赞数
分类专栏： 设计模式 文章标签： 单例模式 设计模式 java
于 2022-08-04 16:19:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ghoul___/article/details/126161779
版权

1、简介

  • 单例模式使⽤场景：

    • 业务系统全局只需要⼀个对象实例，⽐如发号器、 redis 连接对象等。
    • Spring IOC容器中的 Bean 默认就是单例。
    • Spring Boot 中的 Controller、Service、Dao 层中通过 @Autowire的依赖注⼊对象默认都是单例的。

  • 单例模式分类：

    • 懒汉：就是所谓的懒加载，延迟创建对象，需要用的时候再创建对象。
    • 饿汉：与懒汉相反，提前创建对象。

  • 单例模式实现步骤：

    • 私有化构造函数。
    • 提供获取单例的⽅法。

**关键代码：**构造函数是私有的。

应用实例：

  1. 一个班级只有一个班主任。
  2. Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
  3. 一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

2、简单单例实现

我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。

SingleObject 类提供了一个静态方法，供外界获取它的静态实例。SingletonPatternDemo 类使用 SingleObject 类来获取 SingleObject 对象。

在这里插入图片描述

步骤 1
创建一个 Singleton 类。

package Singleton;

public class SingleObject {
    //创建 SingleObject 的唯一对象
    //因为我们使用static进行修饰，所以instance在内存中是唯一的
    private static SingleObject instance = new SingleObject();

    //使构造函数私有，无法实例化
    private SingleObject(){}

    //通过该方法获取唯一对象
    public static SingleObject getInstance(){
        return instance;
    }
    //获取消息
    public void getMessage(){
        System.out.println("Singleton");
    }

}

步骤 2
从 singleton 类获取唯一的对象。

package Singleton;

public class SingletonPatternDemo {
    public static void main(String[] args) {
        //不合法的构造函数
        //SingleObject中构造函数私有，无法通过new关键字进行构造
        //编译时错误：构造函数 SingleObject() 是不可见的
        //SingleObject object = new SingleObject();


        //我们只能通过暴露出来的方法获取唯一的变量值
        SingleObject instance = SingleObject.getInstance();

        instance.getMessage();
    }
}

2、单例模式——懒汉式

单例模式——懒汉式有以下⼏种实现⽅式：

  • 方式一
package com.iswhl.single;

/**
 * @Auther: whl
 * @Date: 2022/8/04/15:36
 * @Description: 单例设计模式-懒汉式
 */
public class SingletonLazy {
    // 当需要用到该实例的时候再创建实例对象
    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     * 不能通过 new SingletonLazy() 的方式创建实例
     *
     * 当需要用到该实例的时候在加载
     * 只能通过 SingletonLazy.getInstance() 这种方式获取实例
     */
    private SingletonLazy() {
    }

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功！");
    }

    /**
     * 方式一：
     * <p>
     * 对外暴露一个方法获取该类的对象
     * <p>
     * 缺点：线程不安全，多线程下存在安全问题
     *
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            /**
             * 线程安全问题：
             * 当某一时刻，两个或多个线程同时判断到instance == null成立的时候
             * 这些线程同时进入该if判断内部执行实例化
             * 则会新建出不止一个SingletonLazy实例
             */
            instance = new SingletonLazy();// 当需要的时候再进行实例化对象
        }
        return instance;
    }
}
  • 方式2
package com.iswhl.single;

/**
 * @Auther: whl
 * @Date: 2022/8/04/15:36
 * @Description: 单例设计模式-懒汉式
 */
public class SingletonLazy {
    // 当需要用到该实例的时候再创建实例对象
    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     * 不能通过 new SingletonLazy() 的方式创建实例
     *
     * 当需要用到该实例的时候在加载
     * 只能通过 SingletonLazy.getInstance() 这种方式获取实例
     */
    private SingletonLazy() {
    }

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功！");
    }

    /**
     * 方式二：
     * 通过加synchronized锁 保证线程安全
     *
     * 采用synchronized 对方法加锁有很大的性能开销
     * 因为当getInstance2()内部逻辑比较复杂的时候，在高并发条件下
     * 没获取到加锁方法执行权的线程，都得等到这个方法内的复杂逻辑执行完后才能执行，等待浪费时间，效率比较低
     *
     * @return
     */
    public static synchronized SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            // 方法上加synchronized锁后可以保证线程安全
            instance = new SingletonLazy();// 当需要的时候再进行实例化对象
        }
        return instance;
    }

}
  • 方式3
package com.iswhl.single;

/**
 * @Auther: whl
 * @Date: 2022/8/04/15:36
 * @Description: 单例设计模式-懒汉式
 */
public class SingletonLazy {
    // 当需要用到该实例的时候再创建实例对象
    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     * 不能通过 new SingletonLazy() 的方式创建实例
     *
     * 当需要用到该实例的时候在加载
     * 只能通过 SingletonLazy.getInstance() 这种方式获取实例
     */
    private SingletonLazy() {
    }

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功！");
    }

    /**
     * 方式三：
     * 在getInstance()方法内，针对局部需要加锁的代码块加锁，而不是给整个方法加锁
     *
     * 也存在缺陷：
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            // 局部加锁后可以保证线程安全,效率较高
            // 缺陷：假设线程A和线程B
            synchronized (SingletonLazy.class){
                // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
                // 当A线程执行完毕后，B再获得执行权，这时候还是可以实例化该对象
                instance = new SingletonLazy();// 当需要的时候再进行实例化对象
            }
        }
        return instance;
    }
}
  • 方式4
package com.iswhl.single;

/**
 * @Auther: whl
 * @Date: 2022/8/04/15:36
 * @Description: 单例设计模式-懒汉式
 */
public class SingletonLazy {
    // 当需要用到该实例的时候再创建实例对象
    private static SingletonLazy instance;

    /**
     * 构造函数私有化
     * 不能通过 new SingletonLazy() 的方式创建实例
     *
     * 当需要用到该实例的时候在加载
     * 只能通过 SingletonLazy.getInstance() 这种方式获取实例
     */
    private SingletonLazy() {
    }

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功！");
    }

    /**
     * 方式三改进版本：
     * 在getInstance3()方法内，针对局部需要加锁的代码块加锁，而不是给整个方法加锁
     *
     * DCL 双重检查锁定 (Double-Checked-Locking) 在多线程情况下保持高性能
     *
     * 这是否安全？ instance = new SingletonLazy(); 并不是原子性操作
     * jvm中 instance实例化内存模型流程如下：
     * 1.分配空间给对象
     * 2.在空间内创建对象
     * 3.将对象赋值给instance引用
     *
     * 假如出现如下顺序错乱的情况：
     * 线程的执行顺序为：1 -> 3 -> 2, 那么这时候会把值写回主内存
     * 则，其他线程就会读取到instance的最新值,但是这个是不完全的对象
     * (指令重排现象)
     *
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            // 局部加锁后可以保证线程安全,效率较高
            // 假设线程A和线程B
            synchronized (SingletonLazy.class){// 第一重检查
                // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
                // 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立
                // 如果不成立，B线程无法 实例化SingletonLazy
                if (instance == null){// 第二重检查
                    instance = new SingletonLazy();// 当需要的时候再进行实例化对象
                }
            }
        }
        return instance;
    }

}
  • 方式5
package com.iswhl.single;

/**
 * @Auther: whl
 * @Date: 2022/8/04/15:36
 * @Description: 单例设计模式-懒汉式
 */
public class SingletonLazy {

    // 添加volatile 关键字，禁止实例化对象时，内存模型中出现指令重排现象
    private static volatile SingletonLazy instance;

    /**
     * 构造函数私有化
     * 不能通过 new SingletonLazy() 的方式创建实例
     *
     * 当需要用到该实例的时候在加载
     * 只能通过 SingletonLazy.getInstance() 这种方式获取实例
     */
    private SingletonLazy() {
    }

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功！");
    }


    /**
     * 方式三再次升级版本：
     * 在getInstance3()方法内，针对局部需要加锁的代码块加锁，而不是给整个方法加锁
     *
     * DCL 双重检查锁定 (Double-Checked-Locking) 在多线程情况下保持高性能
     *
     * 解决指令重排问题——禁止指令重排
     * @return
     */
    public static SingletonLazy getInstance() {
        if (instance == null) {// 实例为null时候才创建
            // 局部加锁后可以保证线程安全,效率较高
            // 假设线程A和线程B
            synchronized (SingletonLazy.class){// 第一重检查
                // 当线程A获得锁的执行权的时候B等待 A执行new SingletonLazy();实例化
                // 当A线程执行完毕后，B再获得执行权，这时候再判断instance == null是否成立
                // 如果不成立，B线程无法 实例化SingletonLazy
                if (instance == null){// 第二重检查
                    instance = new SingletonLazy();// 当需要的时候再进行实例化对象
                }
            }
        }
        return instance;
    }
}

3、单例模式——饿汉式

package com.iswhl.single;

/**
 * @Auther: whl
 * @Date: 2022/8/04/16:39
 * @Description: 单例设计模式-饿汉式
 */
public class SingletonHungry {

    // 当类加载的时候就直接实例化对象
    private static SingletonHungry instance = new SingletonHungry();

    private SingletonHungry(){}

    /**
     * 单例对象的方法
     */
    public void process() {
        System.out.println("方法实例化成功！");
    }

    public static SingletonHungry getInstance(){
        return instance;// 当类加载的时候就直接实例化对象
    }
}
  • 测试
package com.iswhl.juc;

import com.iswhl.single.SingletonHungry;
import com.iswhl.single.SingletonLazy;
import org.junit.jupiter.api.Test;

public class testSingletonLazy {

    @Test
    public void testSingletonLazy(){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                SingletonHungry.getInstance().process();
            }).start();
        }
    }

}

饿汉式单例模式，当类加载的时候就直接实例化对象，因此不需要考虑线程安全问题。

  • 优点：实现简单，不需要考虑线程安全问题。
  • 缺点：不管有没有使用该对象实例，instance对象一直占用着这段内存。

懒汉与饿汉式如何选择？

  • 如果对象内存占用不大，且创建不复杂，直接使用饿汉的方式即可。
  • 其他情况均采用懒汉方式(优选)。
三横同学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面试官最喜欢考的设计模式---单例设计模式
Hacker的博客
03-01 1030
一、讲在前面的废话笔者曾经多次面试都遇到了这个问题，请你说一下软件的设计模式，一般我们都会把23种模式例举几个出来，如果没有说错，你一定会列举单例设计模式，这样的话你就中了面试官的圈套了。接下来的一般情况就是让你细说单例设计模式，然后写代码。二、单例设计模式概述单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外
设计模式面试之单例模式，这一篇就够了
超越无限_
03-16 178
1.什么是单例 保证一个类只有一个实例，并且提供一个访问该全局访问点 2.那些地方用到了单例模式 网站的计数器，一般也是采用单例模式实现，否则难以同步。 应用程序的日志应用，一般都是单例模式实现，只有一个实例去操作才好，否则内容不好追加显 示。 多线程的线程池的设计一般也是采用单例模式，因为线程池要方便对池中的线程进行控制 Windows的（任务管理器）就是很典型的单例模式，他不能打开俩个 windows的（回收站）也是典型的单例应用。在整个系统运行过程中，回收站只维护一个实例。 3.单例优缺点 优点：
单例设计模式（java面试题）
STEphenomenon的博客
09-04 162
1.饿汉式：直接创建对象，不存在线程安全问题 （1）直接实例化饿汉式（简洁直观） （2）枚举式（最简洁） （3）静态代码块饿汉式（适合复杂实例化） 有参形式： 2.懒汉式：延迟创建对象 （1）线程不安全（适用于单线程） （2）线程安全（适用于多线程） （3）静态内部类形式（适用于多线程） ...
单例设计模式(面试重点)
u010481606的专栏
04-09 611
/*  *   * 单例设计模式(面试重点)  *   *   * 懒汉式和饿汉式有什么不同？  * 懒汉式特点是：实例延迟加载  * 缺点：  如过多线程访问会出现安全问题       解决方法：可加同步来解决。用同步代码和同步块都能解决。但是稍微有些低效。用双重判断的方式可以解决低效问题  * 加同步的时候使用的锁是：该类所属的字节码回对象  *   */ //饿
单例设计模式面试题
qq_40095332的博客
03-01 282
单例设计模式分为两种分为 ：  饿汉式     懒汉式  。1. 懒汉式与饿汉式有什么不同？答：懒汉式的特点在于实例延迟加载。2.懒汉式延迟加载有木有问题？如果有怎么解决？答：有，如果多线程访问时，会出现安全问题；解决办法：可以加同步来解决，而加同步的方式同步代码块与同步方法都行，但是稍微有一些低效；用双重判断的形式能解决效率问题。3.加同步的时候使用的锁是哪一个？答：该类所属的字节码文件对象（类...
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
Java设计模式-单例模式详解
11-24
单例模式是 Java 设计模式中的一种常用的设计模式，旨在保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中，某个类有且仅有一个实例。 实现单例模式的步骤： 1. 只有 ...
java设计模式-单例.pdf
最新发布
05-16
### Java设计模式——单例模式详解 #### 一、单例模式概述 单例模式是设计模式中的一个重要组成部分，属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在，并提供一个全局访问该实例的方法。这在很多场景...
常见设计模式-单例模式
07-06
单例模式是设计模式中的一种，其主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。在Java编程中，实现单例模式有多种方式，每种方式都有其优缺点。 1. **饿汉式**： 饿汉式在类加载时即...
c++设计模式-单例模式
06-03
**单例模式**是软件设计模式中的一种，属于创建型模式。在C++中，单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式通常用于管理共享资源，如数据库连接、日志系统或者配置文件等。单例模式的主要...
面试题-单例设计模式
qq_41787659的博客
08-19 144
饿汉式 class Mysingle{ private Mysingle() {}; static private Mysingle my = new Mysingle(); //公共访问点 static public Mysingle getMy() { return my; } } 懒汉式（延迟加载+线程不安全） class Mysingle2{ private Mysingle2() {}; //延迟加载的思想！ static private Mysingle2 my; sta
面试必问——设计模式之单例设计模式
weixin_43397580的博客
09-30 190
相信大家面试的时候，经常会被问到，23种设计模式，你熟悉哪写，手写个单例啥的，当然了，这是对于小程序员的面试，大佬请忽略 单例模式呢，顾名思义就是这个对象只会创建一次。因此他的构造方法必须私有。 那么这只创建一次的对象等你用的时候，又怎么用呢？肯定是需要一个方法返回提供同一个对象，也就是唯一的对象。 单例模式 单例模式(Singleton Pattern)： 确保某一个类只有一个实例，而且自行实例...
设计模式之单例模式——面试经典
m0_52256357的博客
08-10 179
1、单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点3、单例模式的四种代码实现：①饿汉式——线程安全②懒汉式——线程不安全③懒汉式——线程安全④双重锁校验——线程安全·......
JAVA设计模式之单例模式（面试必考）
ljxandzy的博客
11-02 211
单例模式 java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。 懒汉式： 在第一次调用的时候就实例化自己 public class Singleton { private Singleton() {} private static Singleton single=null;
设计模式之单例模式面试总结
lilealyh的博客
11-28 439
单例模式 class SingleInstance { private static SingleInstance instance; private SingleInstance() { } public static SingleInstance getInstance() { if (instance == null) { ...
Java面试常考之 单例设计模式（饿汉式单例、 懒汉式单例）
C_U_N_Z的博客
03-29 332
所谓的单例设计指的是一个类只允许产生一个实例化对象。 对于单例设计模式也有两类形式：懒汉式、饿汉式。 class Singleton{ // 在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象 private final static Singleton INSTANCE = new Singleton() ; // private声明构造 private Singl...
面试必问设计模式之单例模式(超详细)
janyxe的博客
05-20 730
设计模式系列文章目录 面试必问设计模式之基础篇 面试必问设计模式之工厂方法模式(超详细) 面试必问设计模式之单例模式(超详细) 如果本文对你们的开发之路有所帮助，请帮忙点个赞，您的支持是我坚持写博客的动力 【设计模式相关书籍】wx关注【Java从零学架构】，后 台回复【设计模式】自取 前言 上一篇文章带着大家输入学习了设计模式的工厂模式，这篇文章带着大家深入单例模式 项目代码见 https://gitee.com/janyxe/design_patterns 什么是单例模式 保证一个类只有一
Java丨单例设计模式面试题丨饿汉式和懒汉式各自特点
weixin_45290108的博客
09-01 968
饿汉式； /** * 单例设计模式之饿汉式 * 实现； * 1 定义一个私有的构造方法 * 2 提供一个本类的对象的引用（静态） * 3 提供一个获取本类对象的引用的方法 * 特点； * 在实例声明时就创建对象，生命周期长，占内存长，调用时效率高 */ public class Singleton01 { private static Singleto...
面试必备——设计模式之单例模式
xl132598798的博客
04-27 188
单例模式是面试时经常被问到的设计模式之一，由该模式，还可以将话题延伸至线程安全上，要学会将所学知识串起来，在面试时，将面试官的注意力转移到你的擅长领域。
C#实现的23种设计模式-单例模式解析
"该文档是关于23种经典设计模式的C#版本介绍，主要讨论了其中的一种——单例模式（Singleton Pattern）。" 在软件工程中，设计模式是一种被广泛接受并反复使用的解决方案模板，用于解决常见的设计问题。单例模式是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三横同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值