【设计模式 创建型】单例模式

这篇具有很好参考价值的文章主要介绍了【设计模式 创建型】单例模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)

指一个类只有一个实例,且该类能自行创建这个实例的一种模式

特点:

某个类只能有一个实例(即构造器私有,防止外部通过new XXX()创建对象

自行在类的内部创建对象实例

向外暴露一个静态的公共方法

八种单例模式实现方式:

  • 饿汉式(静态常量)

  • 饿汉式(静态代码块)

  • 懒汉式(线程不安全)

  • 懒汉式(线程安全,同步方法)

  • 懒汉式(线程安全,同步代码块)

  • 双重检查

  • 静态内部类

  • 枚举

饿汉式(静态常量)

public class Singleton {
    //创建实例对象
    private final static Singleton instance = new Singleton();

    /**
     * 构造器私有化,防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法,返回实例对象
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

类装载的时候就完成实例化,避免了线程同步问题,如果从始至终都没有用到这个实例,则会造成内存的浪费

饿汉式(静态代码块)

public class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 在静态代码块中,创建单例对象
     */
    static {
        instance = new Singleton();
    }

    /**
     * 构造器私有化,防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法,返回实例对象
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

同上

懒汉式(线程不安全)

当需要使用到对象的时候,才会创建对象即懒汉式

public class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 构造器私有化,防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法,当使用到该方法时,才会创建instance
     * @return
     */
    public static Singleton getInstance() {
        //若对象为空,则创建
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

起到了懒加载的效果,但是只能在单线程下使用,在实际开发中,不要使用这种方式

懒汉式(线程安全,同步方法)

public class YamlUtils {
    private static YamlUtils instance; // 类实例变量
    private YamlUtils() {
        loadConfig(); // 加载配置信息
    }
   /**
     * 提供一个公有的静态方法,加入同步处理,解决线程安全问题
     * @return
     */
    public static synchronized YamlUtils getInstance() {
        if (instance == null) { // 若实例为空,则创建新实例
            instance = new YamlUtils();
        }
        return instance;
    }

    private void loadConfig() {
    }

}

效率低,每个线程在想获得类的实例时候,执行 getInstance()方法都要进行同步,而其实这个方法只执行一次实例化代码就够了,后面的想获得该类的实例,直接 return 就行,方法进行同步效率太低

在实际开发中,不推荐使用

懒汉式(线程安全,同步代码块)

class Singleton {
    //实例对象
    private static Singleton instance;

    /**
     * 构造器私有化,防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法
     * @return
     */
    public static Singleton getInstance() {
        //若对象为空,则创建
        if (instance == null) {
            //同步代码块
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

因为上面实现方式的同步方法效率太低,改为同步产生实例化的代码块

同步并不能起到线程同步的作用,假如一个线程进入了判断语句,还没有执行对象实例化,另一个线程也通过了这个判断语句,这是便会产生多个实例

实际开发中,不能使用这种方式

双重检查 🤠

public class Singleton {
    //实例对象
    private static volatile Singleton instance;

    /**
     * 构造器私有化,防止外部类能直接new
     */
    private Singleton() {}

    /**
     * 提供一个公有的静态方法,加入双重检查处理,解决线程安全问题,
     * 同时解决懒加载问题,也保证了效率
     * @return
     */
    public static Singleton getInstance() {
        //实例没创建,才会进入内部的 synchronized代码块
        if (instance == null) {
            synchronized (Singleton.class) {
                //此处再判断一次,可能会出现其他线程创建了实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

1、DoubleCheck 概念是多线程开发中常使用到的,如代码中所示,进行了两次 if (instance == null)检查,这样就保证了线程安全。
2、实例化代码只用执行一次,后面再次访问时,判断 if (instance == null),直接 return 实例化对象,也避免反复进行方法同步。
3、线程安全,延迟加载,效率较高。
4、推荐使用这种单例设计模式。

静态内部类 🧐

public class Singleton {
    private Singleton() {}

    /**
     * 静态内部类,类中有一个静态属性
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static final Singleton getInstance() {
        return SingletonInstance.INSTANCE ;
    }
}

1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2、静态内部类方式在 Singleton 类被装载时并不会立即实例化,而是在需要实例化时,调用 getInstance 方法时,才会装载 SingletonInstance 类,从而完成 Singleton 的实例化。
3、类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM 帮助我们保证了线程的安全性,在类进行初始化时,别的线程是无法进入的。
4、避免了线程不安全,利用静态内部类特点实现延迟加载,效率高,推荐使用。

枚举实现单例模式

public enum Singleton{
    INSTANCE;
    public Singleton getInstance(){
        return INSTANCE;
    }
}

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE.getInstance();
        Singleton instance2 = Singleton.INSTANCE.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println("instance1=" + instance1.hashCode());
        System.out.println("instance2=" + instance2.hashCode());
    }
}

1、借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象

推荐使用

总结

1、单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能。
2、当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用 new。
3、单例模式使用的场景:
需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(如:数据源、session 工厂等)文章来源地址https://www.toymoban.com/news/detail-807663.html

到了这里,关于【设计模式 创建型】单例模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 学习笔记-设计模式-创建型模式-单例模式

    一个类只有一个实例,并提供一个全局访问此实例的点,哪怕多线程同时访问。 单例模式主要解决了 一个全局使用的类被频繁的创建和消费 的问题。 单例模式的案例场景 数据库的连接池不会反复创建 spring中一个单例模式bean的生成和使用 在我们平常的代码中需要设置全局

    2024年02月08日
    浏览(53)
  • 【地铁上的设计模式】--创建型模式:单例模式(五)--枚举单例

    什么是枚举单例 枚举单例是指使用枚举类型来实现单例模式,它是单例模式中最简单、最安全的一种实现方式。在枚举类型中定义的枚举值只会被实例化一次,即保证了全局唯一的实例,而且实现简单、线程安全、防止反射攻击、支持序列化等。 如何实现枚举单例 实现枚举

    2023年04月25日
    浏览(82)
  • 设计模式-创建型模式(单例、工厂、建造、原型)

    设计模式:软件设计中普遍存在(反复出现)的各种问题,所提出的解决方案。 面向对象三大特性:封装、继承、多态。 面向对象设计的SOLID原则: (1)开放封闭原则:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。即软件实体应尽量在不修改原有代码的情

    2024年02月08日
    浏览(53)
  • c#设计模式-创建型模式 之 单例模式

    目录 前言: 优点: 缺点: 饿汉式(静态变量方式) 懒汉式(线程不安全) 懒汉式(双重检查锁定) 推荐方式Lazy 总结: 这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供 了一种访问其唯一的对象的方式,可以直接访问,

    2024年02月13日
    浏览(39)
  • GO设计模式——4、单例模式(创建型)

    目录 单例模式(Singleton Pattern)   优缺点 使用场景 饿汉式和懒汉式单例模式         单例模式(Singleton Pattern)是一个类 只允许创建一个 对象(或者实例),那这个类就是一个单例类,这种设计模式就叫作单例设计模式,简称单例模式。单例模式的要点有三个:一是

    2024年02月05日
    浏览(49)
  • 【Java 设计模式】创建型之单例模式

    在软件开发中,单例模式是一种常见的设计模式, 它确保一个类只有一个实例,并提供一个全局访问点 。单例模式在需要控制某些资源,如数据库连接池、线程池等共享资源的情况下非常有用。在本文中,我们将介绍 Java 设计模式中的单例模式,了解其实现方式、使用场景

    2024年01月18日
    浏览(55)
  • 深入理解设计模式-创建型之单例模式

    如果有些数据在系统中应该且只能保存一份,那就应该设计为单例类。 如:配置类:在系统中,我们只有一个配置文件,当配置文件被加载到内存之后,应该被映射为一个唯一的【配置实例】,此时就可以使用单例,当然也可以不用。 全局计数器:我们使用一个全局的计数

    2024年02月12日
    浏览(59)
  • C++设计模式创建型之单例模式

    一、概述         单例模式也称单态模式,是一种创建型模式,用于创建只能产生一个对象实例的类。例如,项目中只存在一个声音管理系统、一个配置系统、一个文件管理系统、一个日志系统等,甚至如果吧整个Windows操作系统看成一个项目,那么其中只存在一个任务管理

    2024年02月14日
    浏览(49)
  • Java23种设计模式-创建型模式之单例模式

    单例模式 (Singleton Pattern):通过单例模式的方法创建的 类在当前进程中只有一个实例 (根据需要,也有可能一个线程中属于单例,如:仅线程上下文内使用同一个实例),该类负责 创建自己的对象 ,同时 确保只有单个对象 被创建。 注 : 1、单例类 只能 有 一个实例 。

    2024年04月26日
    浏览(54)
  • 《golang设计模式》第一部分·创建型模式-01-单例模式(Singleton)

    指目标类(Class)只有一个实例对象(Object),并且向使用该对象的客户端提供访问单例的全局方法。 保证类只有一个实例 有方法能让外部访问到该实例 懒汉式 在第一次调用单例对象时创建该对象,这样可以避免不必要的资源浪费 饿汉式 在程序启动时就创建单例对象,这

    2024年02月14日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包