【设计模式】一:单例模式

最新推荐文章于 2024-10-04 16:37:21 发布
最新推荐文章于 2024-10-04 16:37:21 发布
阅读量638 收藏 7
点赞数 17
分类专栏： 设计模式 文章标签： 单例模式 java 后端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ai15013602354/article/details/123266734
版权

前言:

设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。本文是23种设计模式系列的第一篇，意在深入浅出的给大家介绍设计模式。

目录

前言:

概念:

实现方式

一：饿汉式

二:懒汉式

三:通过加锁来解决懒汉式的线程不安全问题

四：减少同步代码块来提高效率

五: 双重检查来保证线程安全

六：静态内部类

七：枚举单例

总结:

概念:

    单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。顾名思义一种只能有单个实例对象的类，我们称之为单例类。要想实现在内存中只能有一份实例，单例类必须封装构造方法，让调用者无法直接构造单例类的实例，同时为了让调用者获取到单例类的实例，因此单例类必须自己实例化本身，并且提供唯一的静态方法让调用者可以通过类名直接调用该方法从而获取到单例类的实例。

注意:

       1:必须保证在内存中单例类只能有一份实例对象。

       2:单例类必须负责单例类本身的实例化。

       3:单例类必须提供唯一的静态方法供调用者调用。

实现方式

一：饿汉式

方式一:

public class Mgr01 {
    private static final Mgr01 INSTANCE=new Mgr01();
    private Mgr01(){};
    public static Mgr01 getInstance(){
        return INSTANCE;
    }
}

方式二:

//和写法一本质上是一样的
public class Mgr02 {
    private static Mgr02 INSTANCE;
    static {
        INSTANCE=new Mgr02();
    }
    private Mgr02(){};
    public static Mgr02 getInstance(){
        return INSTANCE;
    }
}

  💡:分析

   饿汉式的单例模式，在类加载的时候单例类的实例被加载到内存中去。JVM会保证其内存安全，因为一个类只会被加载一次。

是否线程安全:线程安全。

缺点:无论是否使用到都会创建该单例类的实例，但是一般情况下我们在代码中写了这个单例类一般都要使用，所以这个缺点无关紧要。

推荐使用这种方法，简单易操作。

二:懒汉式

  方法一的缺点是无论是否使用都会创建实例，而方法二解决了这个问题，懒汉式单例模式会在使用的时候再去实例化对象。

public class Mgr03 {
    public static Mgr03 INSTANCE;
    private Mgr03(){};
    public static Mgr03 getInstance(){
        if(INSTANCE==null){
            INSTANCE=new Mgr03();
        }
        return INSTANCE;
    }
}

💡：这种懒汉式的实现策略虽然在真正使用的使用在实例化对象，但是却造成了线程不安全的情况。即多个线程同时调用 getInstance() 方法时,会创建多个实例对象违背了单例模式的条件。

🔑:我们可以通过多线程的方式来测试。

public class Mgr03 {
    public 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();

        }
    }
}

运行截图:

  运行结果显示不同线程打印的hashcode不同，说明当前单例类创建了多个实例对象。

优点:单例类在真正被用到的时候再实例对象，减少了内存的开销。

缺点：弥补了懒汉式的不足，但带来的线程安全的问题。

三:通过加锁来解决懒汉式的线程不安全问题

   我们可以通过给 getInstance() 方法上锁，就可以保证每次只有一个线程执行该方法，那么第一个给该方法上锁的线程会实例对象，等到后面所有的线程执行该方法的时候，由于对象已经实例化了，就不会重复实例对象，解决了懒汉式存在的问题。

代码演示:

public class Mgr04 {
    public 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();
        }
    }
}

运行截图:

   由运行结果可以看出不同的线程打印的hashcode均相同，说明该单例类只实例的一个对象。

   优点:在懒汉式的基础上，解决了其线程不安全的问题。

   缺点: 如果getInstance() 方法存在大量被调用的情况，每次调用的过程中都会经历上锁和解锁的过程，这会降低代码的执行效率。

四：减少同步代码块来提高效率

    解决懒汉式的线程不安全的时候我们采用了方法整体加锁，这会降低效率，于是我们想到能否对代码块加锁，通过减少同步代码块的形式提高效率。

代码演示:

public class Mgr05 {
    private static Mgr05 INSTANCE;
    private Mgr05(){};
    public static Mgr05 getInstance(){
        if(INSTANCE==null){
            synchronized (Mgr05.class){
                INSTANCE=new Mgr05();
            }
        }
        return INSTANCE;
    }
}

测试线程是否安全:

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();
        }
    }
}

运行截图:

  不同线程打印出的hashcode不一致，说明不同线程创建了不同的单例对象，违背了单例类只能有一个实例的规则。

我们通过对局部代码块加锁来减少同步代码块从而提高效率结果失败了。

五: 双重检查来保证线程安全

    上一个方法想要通过减少同步代码块的方式提高效率结果失败了，但能否有一种策略确实能够减少同步代码块同时又能保证线程安全呢？

   这时我们就可以通过双重检查实现既减少同步代码块提高效率，又能保证线程安全。

代码演示:

//我们可以加入双检查来确保线程安全
//来确保减少同步代码块的方式可行
public class Mgr06 {
    private static Mgr06 INSTANCE;
    private Mgr06(){};
    public static Mgr06 getInstance(){
        if(INSTANCE==null){
            synchronized (Mgr06.class){
                if(INSTANCE==null){
                    INSTANCE=new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

}

测试线程是否安全:

//我们可以加入双检查来确保线程安全
//来确保减少同步代码块的方式可行
public class Mgr06 {
    private static Mgr06 INSTANCE;
    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();
        }
    }
}

运行截图:

   不同线程打印出的hashcode一致，说明不同线程使用的都是同一个对象，线程安全。

优点：减少同步代码块提高效率。线程安全。

六：静态内部类

    我们可以通过静态内部类的形式来实现单例，既线程安全，又可以在使用的时候进行实例对象。

代码演示：

public class Mgr07 {
    private Mgr07(){};
    private static class Mgr07Holder{
        private static final Mgr07 INSTANCE=new Mgr07();
    }
    public static Mgr07 getInstance(){
        return Mgr07Holder.INSTANCE;
    }
}

   通过静态内部类的方式实现单例，JVM会保证单例类只有一份实例，同时又是线程安全的。

七：枚举单例

   我们可以通过枚举对象的方式保证单例类只有一个实例对象。这种写法可以称作完美的单例写法，既可以解决线程安全，又可以解决同步问题。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。 

public enum Mgr08 {
    INSTANCE;
    public void f(){
        /*
        * 业务逻辑
        * */
    }
}

  🔑:因为枚举类没有构造方法，即便是通过反射也无法在类外创建实例，绝对防止多次实例化，代码简洁优美，建议使用枚举单例。

总结:

  在一般情况下建议使用饿汉式和枚举单例来实现单例模式。

快乐的星球
关注
专栏目录
JS 设计模式之：单例模式定义与实现方法浅析
11-21
本文实例讲述了JS 设计模式之：单例模式定义与实现方法。分享给大家供大家参考，具体如下： 良好的设计模式可以显著提高代码的可读性，降低复杂度和维护成本。笔者打算通过几篇文章通俗地讲一讲常见的或者实用的设计...
5分钟掌握设计模式之：单例模式
12-21
单例模式是软件设计模式中的一种经典模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点。这种模式在很多场景下非常有用，比如控制共享资源、管理配置对象等。下面将详细介绍单例模式的概念、实现方式...
封装pdo单例模式类
weixin_30699463的博客
07-19 118
　　 <?php /** * MyPDO * @author zk <1125035618@qq.com> * @license http://www.sunbloger.com/ */ class MyPDO { protected static $_instance = null; protected $dbName = ''; ...
设计模式——单例模式（Singleton Pattern）
qq_42498542的博客
06-16 674
设计模式——单例模式（Singleton Pattern） 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在有些场景中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，且该类能自行创建这个实例，这就是所谓的单例模式 文章目录设计模式——单例模式（Singleton Pattern）单例模式的优缺点优点缺点单例模式的应用场景单例模式与静态类的区别常见的7种实现方式1.饿汉模式2.懒
设计模式之单例（Singleton）模式
程序员不穿格子衫的博客
04-19 370
一、单例模式 单例模式有3个要点： 1. 某个类只能有一个实例 2. 它必须自行创建这个实例 3. 它必须自行向整个系统提供这个实例 单例模式属于创建型模式的一种，创建型模式是一类最常用的设计模式，在软件开发中应用非常广泛。 创建型模式将对象的创建和使用分离，在使用对象时无需关心对象的创建细节，从而降低系统的耦合度，让设计方案更易于修改和扩展。 每一个创建型模式都在视图回答3个问题： 3W -&...
设计模式之单例模式
刚子的博客
01-30 1619
设计模式之单例模式 单例模式的意思就是只有一个实例。 单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 在应用这个模式时，单例对象的类必须保证只有一个实例存在。 许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。 单例模式属于创建型模式.
快速理解设计模式：单例模式深入
热门推荐
张彦峰的博客
04-21 169万+
单例模式是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。实现方式介绍分析：饿汉式单例模式+懒汉式单例模式（双重检查锁）+静态内部类实现单例模式+注册式单例模式
Java设计模式详解：单例模式
Jz_Stu的博客
03-31 1146
通过掌握单例模式的原理、案例和使用场景，我们可以更加灵活地运用它来解决实际开发中的问题。希望这篇文章能够帮助大家更好地理解和应用单例模式，为后续的Java学习和实践打下坚实的基础。
javascript设计模式一： 单例模式
一期一会的博客
01-07 1261
作为一个半路出家的前端，随着项目经验的积累，也越来越意识到原生js的博大精深，最近正在研究js设计模式，接下来每学一个设计模式就是写篇文章做笔记，其实主要还是代码和设计思想的结合，努力体会，多思考合适自己项目中的应用场景，争取实际应用到实际项目中。 话不多说，进入主题，js设计模式之：单例模式 单例模式定义: 保证一个类仅有一个实例，并提供一个访问它的全局访问点 上代码： 标准单例模式 //方法1...
C++设计模式之：单例模式singleton
weixin_45068267的博客
09-06 1358
it人员无论是使用哪种高级语言开发东东，想要更高效有层次的开发程序的话都躲不开三件套：数据结构，算法和设计模式。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案，使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式坚持七大原则：开闭原则，单一职责原则，里氏替换原则，依赖倒转原则，接口隔离原则，迪米特原则，合成复用原则，而各项设计模式又区分为三大模式，创建型模式，结构型模式，行为模式。
详解设计模式：单例模式
栗筝i的博客
11-27 3866
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 在单例模式中，内存中只会创建且仅创建一次对象在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。 本篇内容包括：关于单例模式、单例模式-饿汉式实现、单例模式-懒汉式实现
探索Java设计模式：单例模式
放码过来
04-21 812
*单例模式（Singleton Pattern）**是一种创建型设计模式，其核心目标是确保一个类在整个应用程序中只存在一个实例，并提供一个全局访问点来获取这个实例。资源优化：对于那些需要频繁创建和销毁、或者占用大量系统资源的对象，单例模式可以保证它们只被创建一次，从而节约资源。状态共享：在需要多个对象共享同一份数据或状态时，单例模式可以提供一个全局唯一的共享点。控制全局访问：对于需要严格控制数量的对象（如数据库连接池、线程池），单例模式可以防止无限制的实例化，保证系统的稳定性和一致性。
设计模式—— 七 ：单例模式
01-21
单例模式的实现饿汉式懒汉式线程安全的懒汉式登记式单例模式的优缺点单例模式的优点单例模式的缺点 单例模式是23个模式中比较简单的模式，应用也非常广泛 什么是单例模式？ 单例模式的定义： Ensure a class ...
C++中的三大设计模式：单例模式、工厂模式与观察者模式的代码实现
09-18
内容概要：本文档介绍了三个经典的软件设计模式——单例模式(Singleton Pattern)、工厂模式(Factory Pattern)以及观察者模式(Observer Pattern)的具体实现，并给出了带有详细注释的C++代码范例。对每个设计模式都有...
C++并发编程实战—单例模式与线程池实现
最新发布
weixin_45706195的博客
10-04 1123
定义：线程池是一种设计模式，它预先创建并维护一定数量的线程，这些线程可以重复执行多个任务。当有任务需要执行时，线程池会选择一个可用的线程来执行任务，任务执行完毕后，线程会返回线程池，等待下一个任务的到来。功能降低线程创建和销毁的开销：线程的创建和销毁是比较耗费资源的操作，使用线程池可以避免频繁地创建和销毁线程，从而提高程序的性能。提高系统的响应速度：线程池中的线程可以立即执行任务，而不需要等待线程的创建和启动时间。
C++实现单例模式
weixin_45186425的博客
09-29 500
C++单例模式实现
常用设计模式之单例模式、策略模式、工厂模式
L_2162的博客
09-29 1212
单例模式属于创建型模式饿汉模式：立即加载懒汉模式，懒加载线程不安全线程安全双重锁静态内部类。
【C++】单例模式
2301_80035097的博客
10-02 462
本篇文章将讲到，静态成员变量，静态函数，以及单例模式案例。
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值