单例设计模式

已于 2023-05-12 18:36:18 修改
阅读量283 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 单例模式
于 2023-05-11 23:14:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bxp1321/article/details/130632487
版权

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例

优点：不会频繁地创建和销毁对象，浪费系统资源。

使用场景：IO 、数据库链接、Redis 连接等。

单例模式的实现方式

主要有饿汉式  懒汉式 静态内部类  枚举

饿汉式：

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 饿汉式
 * 类加载到内存后，就是李华一个单例，JVM保证线程安全
 * 简单实用，推荐使用
 * 唯一缺点，不管用到与否，类装在时就完成实例化
 *
 * @date 2023/5/10 23:35
 */
public class Mgr01 {
    private  static final Mgr01 INSTANCE=new Mgr01();

    private Mgr01() {
    }

    public static Mgr01 getInstance(){return INSTANCE;}

    public static void main(String[] args) {
        Mgr01 m1=Mgr01.getInstance();
        Mgr01 m2=Mgr01.getInstance();
        System.out.println(m1==m2);
    }
}

静态代码块：

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 静态代码块
 * 
 * @date 2023/5/10 23:35
 */
public class Mgr02 {
    private  static final Mgr02 INSTANCE;
    static{
        INSTANCE=new Mgr02();
    }
    private Mgr02() {
    }

    public static Mgr02 getInstance(){return INSTANCE;}

    public static void main(String[] args) {
        Mgr02 m1= Mgr02.getInstance();
        Mgr02 m2= Mgr02.getInstance();
        System.out.println(m1==m2);
    }
}

懒汉式1：线程不安全不推荐

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * @date 2023/5/10 23:35
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {

        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Mgr03.getInstance().hashCode());
            }).start();
        }
    }
}

懒汉式2：加锁，但是效率较低，也不推荐

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized加锁解决，但是会带来效率降低
 * @date 2023/5/10 23:35
 */
public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

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

    public static void main(String[] args) {

        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Mgr04.getInstance().hashCode());
            }).start();
        }
    }
}

懒汉式3：加锁，但是没有双重校验，也会重复创建对象

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized加锁解决，但是会带来效率降低
 * @date 2023/5/10 23:35
 */
public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
    }

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {
            //多线程执行时，等待锁的时候别人实例化好了，这里没有判断实力是否为空，所以会重复执行
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

懒汉式4：双重校验，推荐

指令重排可能会破坏单例，可以通过volatile关键字防止指令重排

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized加锁解决，但是会带来效率降低
 * @date 2023/5/10 23:35
 */
public class Mgr06 {
    private volatile static Mgr06 INSTANCE; //使用volatile关键字进行修饰，防止指令重排/**

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //多线程执行时，等待锁的时候别人实例化好了，这里没有判断实力是否为空，所以会重复执行
            //双重检查
            synchronized (Mgr06.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

静态内部类：推荐

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 静态内部类 jvm保证单例
 * 加载外部类的时候不会加载内部类，这样可以实现懒加载
 * @date 2023/5/10 23:35
 */
public class Mgr07 {
    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }
}

枚举：推荐，还可以防止反序列化

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 枚举代理 不仅可以解决线程同步 还可以防止反序列化
 * @date 2023/5/10 23:35
 */
public enum Mgr08 {
    INSTANCE;

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }
}

那些方式可以破坏单例？

反射调用构造函数：单例模式，私有化构造函数，只能内部创建对象，但是通过反射，可以打破单例模式。

可以修改构造函数，防止反射破坏单例

package com.sky.designpattern.singleton;

/**
 * @author sky
 * @Description 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized加锁解决，但是会带来效率降低
 * @date 2023/5/10 23:35
 */
public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
        if(INSTANCE!=null){
            throw new RuntimeException("组织反射破坏单例");
        }
    }

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {
            //多线程执行时，等待锁的时候别人实例化好了，这里没有判断实力是否为空，所以会重复执行
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

序列化反序列化

反射在通过 newInstance 创建对象时，会检查该类是否被 ENUM 修饰，如果是则直接抛出异常，反射失败，所以枚举是不怕反射暴力破解构造器的

枚举可以防止序列化反序列化重复创建对象。

  • 序列化的时候，仅仅是将枚举对象的 name 属性输出到结果中
  • 反序列化的时候则是通过 java.lang.Enum 的 valueOf 方法 来根据 name 查找枚举对象
bxp1321
关注
专栏目录
单例设计模式实现总结
12-22
单例设计模式是一种常用的设计模式，其主要目的是确保一个类只有一个实例，并且提供全局访问点。这在处理一些需要共享的资源或者全局状态时非常有用，比如日志服务、配置管理或者缓存服务等。单例模式有以下关键点：...
浅谈java单例设计模式
01-21
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象： 将类的构造器的访问...
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
单例设计模式详解
玦尘的博客
05-07 2071
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
前端开发之单例设计模式
weijia_kmy的博客
09-09 685
单例模式（Singleton Pattern）是一种常见的设计模式，它确保在整个应用程序的生命周期中，一个类只能创建一个实例。无论你在代码的任何地方尝试创建该类的新实例，它都会返回已经存在的唯一实例。这在需要共享资源、全局状态、缓存、数据库连接等场景非常有用。单例模式在某些场景下非常有用，特别是当我们需要确保某个类只有一个实例时。通过 TypeScript 实现单例模式，我们可以利用面向对象的特性来确保类的唯一实例。此外，PlantUML 的类图帮助我们更好地理解单例模式的设计结构。数据库连接管理。
简单介绍单例设计模式以及单例设计模式的应用实例
2301_79585405的博客
09-09 1687
单例设计模式是一种常用的软件设计模式，它确保一个类仅有一个实例，并提供一个全局访问点来获取这个实例。这种模式在多线程环境下尤其重要，需要确保线程安全地创建实例。
单例模式（单例设计模式）详解
GJ_007的博客
03-31 4万+
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程
Java设计模式之单例设计模式
qq_46656580的博客
04-17 1029
15.1.单例模式的介绍 单例即单个的实例 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法 单例模式有两种方式：饿汉式 和 懒汉式 15.2.单例模式步骤： 构造器私有化 ----- 防止外部直接 new 一个对象，造成创建多个对象 类的内部创建对象 向外暴露一个静态的公共方法 15.3.饿汉式 类加载到内存后，就实例化一个单例，JVM保证线程安全 唯一缺点：不管用到与否，类加载时就完成实例化，存在浪费资源的可能
单例设计模式(8种)
weixin_49329785的博客
08-04 1509
/* * 单例设计模式： * 1.所谓的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 * * 2.如何实现？ * 饿汉式 vs 懒汉式 * 3.区分饿汉式和懒汉式 * 饿汉式：（创建时就已经存在对象） * 坏处：对象加载时间过长。 * 好处：饿汉式是线程安全的。 * 懒汉式： * 好处：延迟对象的创建 * 目前写法的坏处：线程不安全。---->到多线程内容时，在修改 * */ public class Si.
设计模式之单例模式
qq_74811378的博客
09-02 1157
（Singleton）是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。（Singleton） 类声明了一个名为获取实例的静态方法来返回其所属类的一个相同实例。单例的构造函数必须对客户端 （Client） 代码隐藏。调用方法必须是获取单例对象的唯一方式。new如果你的代码能够访问单例类， 那它就能调用单例类的静态方法。无论何时调用该方法， 它总是会返回相同的对象。适用场景（Singleton） 类声明了一个名为获取实例的静态方法来返回其所属类的一个相同实例。
Java 单例设计模式
枯寂家博客
10-28 1257
Java单例设计模式 一、什么是单例设计模式 单例设计模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 二、如何应用单例设计模式 根据定义，一个类只能存在一种对象实例，所以我们需将类的构造访问权限设置成private，只能在类内进行操作。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。 三、单例设计
单例设计模式.pdf
07-27
单例设计模式是一种在软件设计中广泛使用的设计模式，它属于创建型模式，其核心目标是确保类只有一个实例，并提供一个全局访问点。这个模式在Java中尤其常见，因为Java的垃圾回收机制允许对象长时间驻留在内存中，...
单例设计模式源码和案例解析
01-30
单例设计模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在Java编程中，单例模式的应用广泛，例如控制资源的共享、管理配置信息等。本篇将深入解析单例设计模式的四种实现方式，并通过...
状态模式：封装对象状态并改变行为的设计模式
wrxfxdd的博客
10-31 413
状态模式：封装对象状态并改变行为的设计模式
Java设计模式之责任链模式
cxbtdd的博客
11-02 188
责任链模式(Iterator Pattern)是一种行为型设计模式，使多个对象都有机会处理同一个请求，将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。处理器链HandlerChain：通过数组或链表组织各个具体的处理器形成一个处理器链，提供添加处理器的方法，并调用处理器的处理方法。2.在请求处理器个数未知的情况下，或者请求处理器可动态配置的情况下，可以使用责任链模式。具体处理器Handler：对抽象处理器的具体实现，重写处理方法，调用处理器链的方法。4、使用责任链模式的样例代码一。
设计模式概述
小林的博客
10-30 390
直到1995 年，艾瑞克·伽马（ErichGamma）、理査德·海尔姆（Richard Helm）、拉尔夫·约翰森（Ralph Johnson）、约翰·威利斯迪斯（John Vlissides）等 4 位作者合作出版了《设计模式：可复用面向对象软件的基础》一书，在此书中收录了 23 个设计模式，这是设计模式领域里程碑的事件，导致了软件设计模式的突破。GoF（四人组）书中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。
【Java】设计模式——单例设计模式
最新发布
啊松同学的博客
11-02 552
单例设计模式介绍
C++实现单例设计模式详解
"C++单例设计模式是一种常用的设计模式，用于确保一个类只有一个实例，并提供全局访问点。它在多种场景下应用广泛，如系统日志、GUI应用、MODEM连接等。虽然可以通过全局变量实现，但这种方法不够优雅且可能导致多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值