设计模式之单例模式

pluto_charon 2023-03-28 原文

介绍：

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

比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象，SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够了，这是就会使用到单例模式。

比如，在一个系统中需要掉用外部系统的类，一般需要创建一个外部对象的连接对象，这个对象也可以设计成单例模式。

单例模式的类型：

代码实例：

1.饿汉式（静态常量）

优点：写法简单，就是在类装载的时候就完成实例化，避免了线程同步的问题

缺点：在类装载的时候就完成实例化，没有达到懒加载的效果，如果从始至终从未使用过这个实例，则会造成内存浪费

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多，因此不能确定有其他的方式导致类装载，这时候初始化instance就没有达到懒加载的效果

package com.charon.singlecase.type1;

/**
 * @className: Singleton01
 * @description: 饿汉式  如jdk中的Runtime类
 * @author: charon
 * @create: 2022-03-05 23:09
 */
public class Singleton01 {

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

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private final static Singleton instance = new Singleton();

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

2.饿汉式（静态代码块）

与上面的方式类似，只不过将实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

package com.charon.singlecase.type2;

/**
 * @className: Singleton02
 * @description: 饿汉式（静态变量）
 * @author: charon
 * @create: 2022-03-05 23:22
 */
public class Singleton02 {

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

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

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

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

3.懒汉式（线程不安全）

起到了懒加载的效果，但是只能在单线程下使用，如果多线程情况下，一个线程进入了if(instance == null )判断语句，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种方式。

package com.charon.singlecase.type3;

/**
 * @className: Singleton03
 * @description:
 * @author: charon
 * @create: 2022-03-06 15:51
 */
public class Singleton03 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null ){
            instance = new Singleton();
        }
        return instance;
    }
}

4.懒汉式（线程安全，同步方法）

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

package com.charon.singlecase.type4;

/**
 * @className: Singleton04
 * @description:
 * @author: charon
 * @create: 2022-03-06 15:51
 */
public class Singleton04 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * 加入synchronized同步处理的关键字，解决线程安全的问题
     * @return
     */
    public static synchronized Singleton getInstance(){
        if(instance == null ){
            instance = new Singleton();
        }
        return instance;
    }
}

5.懒汉式（线程安全，同步代码块）

这种方式，本意是想对第四种实现方式进行改进，因为前面同步方法的颗粒度太大，因此改为同步产生实例化的代码块。

但是这种同步并不能起到线程同步的作用，跟第三种实现方式遇到的情形一致，加入一个线程进入了if(instance == null )判断语句，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例

package com.charon.singlecase.type5;

/**
 * @className: Singleton05
 * @description:
 * @author: charon
 * @create: 2022-03-06 16:16
 */
public class Singleton05 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * 加入synchronized同步处理的关键字，解决线程安全的问题
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null ){
            synchronized(Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

6.双重检查（推荐使用）

双重检查是多线程开发中常使用到的，在代码中，保证了线程安全。并且，实例化代码只用执行一次，后面再次访问时，判断if(instance == null )，直接return实例化对象，也避免了反复进行方法同步。

package com.charon.singlecase.type6;

/**
 * @className: Singleton06
 * @description:
 * @author: charon
 * @create: 2022-03-06 16:22
 */
public class Singleton06 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
    }
}

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 本类内部创建对象实例
     */
    private static volatile Singleton instance;

    /**
     * 提供一个公有的静态方法，当使用到该方法时，采取创建instance
     * 加入双重检查代码，解决线程安全的问题，同时解决了懒加载的问题，并保证效率
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null ){
            synchronized(Singleton.class){
                if (instance == null ){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

7.静态内部类（推荐使用）

采用了类装载机制来保证初始化实例时只有一个线程。在当外部类被装载的时候，静态内部类不会被装载。当需要用的时候，才会装载静态内部类，而类的静态属性只会在第一次加载类的时候初始化。所以这里是jvm的类装载机制保证了线程安全。

package com.charon.singlecase.type7;

/**
 * @className: Singleton07
 * @description: 使用静态内部类完成单例模式
 * @author: charon
 * @create: 2022-03-06 16:29
 */
public class Singleton07 {

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

class Singleton{

    /**
     * 构造器私有化，外部能new创建
     */
    private Singleton(){

    }

    /**
     * 静态内部类
     */
    private static class SingletonInstance{
        public static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 提供一个公有的静态方法，直接返回SingletonInstance.INSTANCE
     * @return
     */
    public static Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

注意事项和细节说明：

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统的性能
当想实例化一个单例类的时候，必须要使用相应的获取对象的方法，而不是使用new
单例模式的使用场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象

模式设计模式 Singleton instance getInstance 软件设计

有关设计模式之单例模式的更多相关文章

ruby-on-rails - Rails - 子类化模型的设计模式是什么？ - 2
我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？最佳答案通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co
ruby - 解析 RDFa、微数据等的最佳方式是什么，使用统一的模式/词汇(例如 schema.org)存储和显示信息 - 2
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
ruby - 如何在续集中重新加载表模式？ - 2
鉴于我有以下迁移:Sequel.migrationdoupdoalter_table:usersdoadd_column:is_admin,:default=>falseend#SequelrunsaDESCRIBEtablestatement,whenthemodelisloaded.#Atthispoint,itdoesnotknowthatusershaveais_adminflag.#Soitfails.@user=User.find(:email=>"admin@fancy-startup.example")@user.is_admin=true@user.save!ende
ruby-on-rails - 使用 rails 4 设计而不更新用户 - 2
我将应用程序升级到Rails4，一切正常。我可以登录并转到我的编辑页面。也更新了观点。使用标准View时，用户会更新。但是当我添加例如字段:name时，它不会在表单中更新。使用devise3.1.1和gem'protected_attributes'我需要在设备或数据库上运行某种更新命令吗？我也搜索过这个地方，找到了许多不同的解决方案，但没有一个会更新我的用户字段。我没有添加任何自定义字段。最佳答案如果您想允许额外的参数，您可以在ApplicationController中使用beforefilter，因为Rails4将参数
ruby - 是否有用于序列化和反序列化各种格式的对象层次结构的模式？ - 2
给定一个复杂的对象层次结构，幸运的是它不包含循环引用，我如何实现支持各种格式的序列化？我不是来讨论实际实现的。相反，我正在寻找可能会派上用场的设计模式提示。更准确地说:我正在使用Ruby，我想解析XML和JSON数据以构建复杂的对象层次结构。此外，应该可以将该层次结构序列化为JSON、XML和可能的HTML。我可以为此使用Builder模式吗？在任何提到的情况下，我都有某种结构化数据-无论是在内存中还是文本中-我想用它来构建其他东西。我认为将序列化逻辑与实际业务逻辑分开会很好，这样我以后就可以轻松支持多种XML格式。最佳答案我最
LC滤波器设计学习笔记（一）滤波电路入门 - 2
目录前言滤波电路科普主要分类实际情况单位的概念常用评价参数函数型滤波器简单分析滤波电路构成低通滤波器RC低通滤波器RL低通滤波器高通滤波器RC高通滤波器RL高通滤波器部分摘自《LC滤波器设计与制作》，侵权删。前言最近需要学习放大电路和滤波电路，但是由于只在之前做音乐频谱分析仪的时候简单了解过一点点运放，所以也是相当从零开始学习了。滤波电路科普主要分类滤波器：主要是从不同频率的成分中提取出特定频率的信号。有源滤波器：由RC元件与运算放大器组成的滤波器。可滤除某一次或多次谐波，最普通易于采用的无源滤波器结构是将电感与电容串联，可对主要次谐波（3、5、7）构成低阻抗旁路。无源滤波器：无源滤波器，又称
计算机毕业设计ssm+vue基本微信小程序的小学生兴趣延时班预约小程序 - 2
项目介绍随着我国经济迅速发展,人们对手机的需求越来越大,各种手机软件也都在被广泛应用,但是对于手机进行数据信息管理,对于手机的各种软件也是备受用户的喜爱小学生兴趣延时班预约小程序的设计与开发被用户普遍使用,为方便用户能够可以随时进行小学生兴趣延时班预约小程序的设计与开发的数据信息管理,特开发了小程序的设计与开发的管理系统。小学生兴趣延时班预约小程序的设计与开发的开发利用现有的成熟技术参考,以源代码为模板,分析功能调整与小学生兴趣延时班预约小程序的设计与开发的实际需求相结合,讨论了小学生兴趣延时班预约小程序的设计与开发的使用。开发环境开发说明：前端使用微信微信小程序开发工具：后端使用ssm：VU
ruby-on-rails - environment.rb 中设置的常量在开发模式中消失 - 2
了解Rails缓存如何工作的人可以真正帮助我。这是嵌套在Rails::Initializer.runblock中的代码:config.after_initializedoSomeClass.const_set'SOME_CONST','SOME_VAL'end现在，如果我运行script/server并发出请求，一切都很好。然而，在我的Rails应用程序的第二个请求中，一切都因单元化常量错误而变得糟糕。在生产模式下，我可以成功发出第二个请求，这意味着常量仍然存在。我已通过将以上内容更改为以下内容来解决问题:config.after_initializedorequire'some_cl
ruby-on-rails - 设计注册确认 - 2
我在我的项目中有一个用户和一个管理员角色。我使用Devise创建了身份验证。在我的管理员角色中，我没有任何确认。在我的用户模型中，我有以下内容:devise:database_authenticatable,:confirmable,:recoverable,:rememberable,:trackable,:validatable,:timeoutable,:registerable#Setupaccessible(orprotected)attributesforyourmodelattr_accessible:email,:username,:prename,:surname,:
Ruby:标准递归模式 - 2
我经常迷上ruby的一件事是递归模式。例如，假设我有一个数组，它可能包含无限深度的数组作为元素。所以，例如:my_array=[1,[2,3,[4,5,[6,7]]]]我想创建一个方法，可以将数组展平为[1,2,3,4,5,6,7]。我知道.flatten可以完成这项工作，但这个问题是作为我经常遇到的递归问题的一个例子-因此我试图找到一个更可重用的解决方案。简而言之-我猜这种事情有一个标准模式，但我想不出任何特别优雅的东西。任何想法表示赞赏最佳答案递归是一种方法，它不依赖于语言。您在编写算法时要考虑两种情况:再次调用函数的情

设计模式之单例模式

介绍：

单例模式的类型：

代码实例：

注意事项和细节说明：

随机推荐