JAVA设计模式零基础解析之单例模式的八种方式

目录
  • 单例模式简介:
  • 单例模式优点:
  • 应用场景:
  • 单例设计模式的八种方式:
    • 1、饿汉式(静态常量)
    • 2、饿汉式(静态代码块)
    • 3、懒汉式(线程不安全)
    • 4、懒汉式(线程安全,同步方法)
    • 5、懒汉式(线程安全,同步代码块)
    • 6、双重检查(推荐使用)
    • 7、静态内部类(推荐使用)
    • 8、枚举(推荐使用)
  • 单例模式在JDK应用的源码分析
  • 单例模式注意事项和细节说明

单例模式简介:

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。

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

单例模式优点:

  • 由于其在内存中只有一个对象实例,则节省内存空间
  • 能避免频繁地创建和销毁对象,提高性能
  • 避免对共享资源的多重占用,简化访问操作,如在进行写文件时,由于只有一个实例对象,能避免对同一资源的同时写操作
  • 为整个系统提供一个全局访问点,优化和共享资源访问。

应用场景:

单例模式其核心在于在整个系统中只创建唯一一个实例,其应用场景主要如下:

  • 1.创建对象时耗时过多或者耗资源过多,但又经常用到的对象。
  • 2.需要频繁实例化然后销毁的对象。如多线程的线程池、网络连接池等。
  • 3.当对象需要被共享的场合。由于单例模式只允许创建一个对象,共享该对象可以节省内存,并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
  • 4.需要频繁创建的一些类,使用单例可以降低系统的内存压力,减少 GC。
  • 5.网站的计数器(否则难以同步)
  • 6.Windows的任务管理器和回收站。

单例设计模式的八种方式:

1、饿汉式(静态常量)

应用实例:

  • 1.构造器私有化(防止new)
  • 2.类的内部创建对象
  • 3.向外暴露一个静态的公共方法:getInstance
  • 4.代码实现
public class SingletonTest01 {
    public static void main(String[] args) {
        //测试
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1=instance1);    //true
        System.out.println("instance1.hsashCode="+instance1.hashCode());
        System.out.println("instance2.hsashCode="+instance2.hashCode());
    }
}
//饿汉式顾名思义是饥饿的,因此应该开始就创建对象
class Singleton{
    // 1.构造器私有化,外部不能new
    private Singleton(){
    }
    // 2.本类内部创建对象实例
    private final static Singleton instance=new Singleton();
    // 3.提供一个公有的静态方法,返回实例对象
    public static Singleton getInstance(){
        return instance;
    }
}

运行结果:

优缺点说明:

  • 1、优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
  • 2、缺点:在类装载的时候就完成实例化,没有达到Lazy Loading 的效果。如果从始至终从未使用过这个实例,则会造成内存的浪费
  • 3、这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance就没有达到lazy loading 的效果

结论:这种单例模式可用,但是可能造成内存浪费

2、饿汉式(静态代码块)

class Singleton01{
    // 1.构造器私有化,外部不能new
    private Singleton01(){
    }
    // 2.本类内部创建对象实例
    private  static Singleton01 instance;
    static {  //在静态代码块中,创建单例对象
        instance=new Singleton01();
    }
    // 3.提供一个公有的静态方法,返回实例对象
    public static Singleton01 getInstance(){
        return instance;
    }
}

优缺点说明:和上面一样这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也就是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。

3、懒汉式(线程不安全)

public class SingletonTest03 {
    public static void main(String[] args) {
        //测试
        System.out.println("懒汉式,线程不安全~");
        Singleton03 instance1 = Singleton03.getInstance();
        Singleton03 instance2 = Singleton03.getInstance();
        System.out.println(instance1==instance2);    //true
        System.out.println("instance1.hsashCode="+instance1.hashCode());
        System.out.println("instance2.hsashCode="+instance2.hashCode());
    }
}
//懒汉式顾名思义就是懒,不会跟饿汉式一样上来就创建对象,而是在需要的时候才会创建,而且是仅创建一次
class Singleton03{
    // 1.构造器私有化,外部不能new
    private Singleton03(){
    }
    // 2.本类内部创建对象实例
    private  static Singleton03 instance;

    // 3.提供一个公有的静态方法,当使用到该方法时,才会去创建instance
    //即懒汉式
    public static Singleton03 getInstance(){
        if(instance==null){
            instance=new Singleton03();
        }
        return instance;
    }
}

运行结果:

优缺点说明:

  • 1、起到了Lazy Loading的效果,但是只能在单线程下使用。
  • 2、如果在多线程下,一个线程进入了if (singleton == mull)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式
  • 3、结论:在实际开发中,不要使用这种方式.

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

class Singleton04{
    // 1.构造器私有化,外部不能new
    private Singleton04(){
    }
    // 2.本类内部创建对象实例
    private  static Singleton04 instance;
    // 3.提供一个公有的静态方法,加入同步处理的代码,解决线程安全问题
    //即懒汉式
    public static synchronized  Singleton04 getInstance(){
        if(instance==null){
            instance=new Singleton04();
        }
        return instance;
    }
}

运行结果:

优缺点说明:

  • 1、解决了线程安全问题
  • 2、效率太低了,每个线程在想获得类的实例时候,执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了,后面的想获得该类实例,直接return就行了。方法进行同步效率太低
  • 3、结论:在实际开发中,不推荐使用这种方式

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

class Singleton05{
    // 1.构造器私有化,外部不能new
    private Singleton05(){
    }
    // 2.本类内部创建对象实例
    private  static Singleton05 instance;
    // 3.提供一个公有的静态方法,加入同步代码块
    public static Singleton05 getInstance(){
        if(instance==null){
          synchronized (Singleton05.class){
              instance=new Singleton05();
          }
        }
        return instance;
    }
}

优缺点说明:

  • 1、这种方式,本意是想对第四种实现方式的改进,因为前面同步方法效率太低,改为同步产生实例化的的代码块
  • 2、但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致,假如一个线程进入了if (singleton == nul)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例

结论:在实际开发中,不能使用这种方式

6、双重检查(推荐使用)

//双重检查
class Singleton06{
    // 1.构造器私有化,外部不能new
    private Singleton06(){
    }
    // 2.本类内部创建对象实例
    private  static volatile Singleton06 instance;
    // 3.提供一个公有的静态方法,加入双重检查代码,解决线程安全问题,同时解决懒加载问题
    public static synchronized Singleton06 getInstance(){
        if(instance==null){
          synchronized (Singleton06.class){
              if(instance==null){
                  instance=new Singleton06();
              }
          }
        }
        return instance;
    }
}

运行结果:

优缺点说明:

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

为什么一定使用volatile?

在java内存模型中,volatile 关键字作用是:

  • 保证不同线程对变量操作的内存可见性
  • 禁止指令重排序

7、静态内部类(推荐使用)

//静态内部类完成,推荐使用
class Singleton07{
    // 1.构造器私有化
    private Singleton07(){
    }
    // 2.本类内部创建对象实例
    private  static volatile Singleton07 instance;
    //写一个内部静态类,该类中有一个静态的属性
    private static class SingletonInstance{
        private static final Singleton07 INSTANCE=new Singleton07();
    }
    // 3.提供一个公有的静态方法,直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton07 getInstance(){

        return SingletonInstance.INSTANCE;
    }
}

运行结果:

优缺点说明:

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

8、枚举(推荐使用)

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton08 instance = Singleton08.INSTANCE;
        Singleton08 instance2 = Singleton08.INSTANCE;
        System.out.println(instance==instance2);

        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        instance.sayOk();
    }
}
//使用枚举,可以实现单例,推荐
enum Singleton08{
    INSTANCE;//属性
    public void sayOk(){
        System.out.println("ok~");
    }
}

运行结果:

优缺点:

  • 1、这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。
  • 2、这种方式是Effective Java作者Josh Bloch提倡的
  • 3、方式结论:推荐使用

单例模式在JDK应用的源码分析

在我们JDK中,java.lang.Runtime就是经典的单例模式(饿汉式)
从以下源码可以看出:

单例模式注意事项和细节说明

  • 1、单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
  • 2、当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
  • 3、建议不要使用反射进行设计单例模式,因为反射可以暴力破坏单例模式

到此这篇关于JAVA设计模式零基础解析之单例模式的八种方式的文章就介绍到这了,更多相关Java 设计模式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java中单例模式的七种写法示例

    目录 前言 1.饿汉式(线程安全)⭐ 2.懒汉式(线程不安全)⭐ 3.懒汉式(加锁) 4.懒汉式(双重校验锁)⭐ 5.单例模式(静态内部类) 6.单例模式(CAS) 7.单例模式(枚举) 总结 前言 大家好,我是三乙己.考上大家一考:"单例模式的单例,怎样写的?" "不就是构造方法私有化么?" "对呀对呀!--单例模式有七种写法,你知道么?" 言归正传-- 单例模式(Singleton Pattern)可以说是最简单的设计模式了. 用一个成语来形

  • Java设计模式系列之深入浅出单例模式

    目录 前言 饿汉式 懒汉式 线程安全问题 volatile的作用 总结 前言 我不知道大家工作或者面试时候遇到过单例模式没,面试的话我记得我当时在17年第一次实习的时候,就遇到了单例模式,面试官是我后来的leader,当时就让我手写单例,我记得我就写出了饿汉式,懒汉式,但是并没说出懒汉和饿汉的区别,当时他给我一通解释我才知道了其中的奥秘. 写这篇文章之前我刻意的在我手上的项目里面去找了找,我发现单例在每个项目里面都有运用到,而且我后面所说的几种实现还基本上都涉及了,还挺有意思的. 开篇我就给大家

  • Java单例模式分析

    目录 单例模式 为什么要用单例 单例的关键点 几种写法 懒汉式 饿汉式 静态内部类写法 枚举单例 容器实现单例 参考 总结 单例模式 为什么要用单例 确保某个类只有一个对象,常用于访问数据库操作,服务的配置文件等. 单例的关键点 1.默认构造函数为private,复制构造函数和复制赋值函数也要private或=delete禁用.(做到无法被外部其他对象构造) 2.通过一个静态方法或枚举返回单例类对象. 3.确保多线程的环境下,单例类对象只有一个. 几种写法 本文主要介绍C++的懒汉式和饿汉式写法

  • Java设计模式之单例模式深入探索

    目录 什么是设计模式? 单例模式是什么? 单例模式设计的原则是什么? Java实现单例模式的5种方式? 懒汉 饿汉 静态内部类 双重校验锁DCL(Double Check Lock) 枚举(num) 小结 ❤️‍您好,我是贾斯汀,今天来聊一聊单例模式!❤️‍ 什么是设计模式? 百科: 设计模式是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结. 设计模式是软件行业的通用的设计标准,在Java同样通用,主要有23种设计模式如下: 有的小伙伴可能会问,这么多,学得完吗? 答:不好意思

  • Java单例模式的6种实现方式详解

    目录 为什么使用单例模式 使用单例模式需要注意的关键点 单例模式的几种写法 1. 饿汉式 2. 懒汉式 3. DCL(Double CheckLock)实现单例 4. 静态内部类 5. 枚举单例 6. 容器实现单例 总结 为什么使用单例模式 需要确保某个类只要一个对象,或创建一个类需要消耗的资源过多,如访问IO和数据库操作等,这时就需要考虑使用单例模式了. 使用单例模式需要注意的关键点 将构造函数访问修饰符设置为private 通过一个静态方法或者枚举返回单例类对象 确保单例类的对象有且只有

  • JAVA设计模式零基础解析之单例模式的八种方式

    目录 单例模式简介: 单例模式优点: 应用场景: 单例设计模式的八种方式: 1.饿汉式(静态常量) 2.饿汉式(静态代码块) 3.懒汉式(线程不安全) 4.懒汉式(线程安全,同步方法) 5.懒汉式(线程安全,同步代码块) 6.双重检查(推荐使用) 7.静态内部类(推荐使用) 8.枚举(推荐使用) 单例模式在JDK应用的源码分析 单例模式注意事项和细节说明 单例模式简介: 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一.这种类型的设计模式属于创建型模式,它提供了

  • Java 解析XML数据的4种方式

    解析的四种方式 DOM 解析 SAX 解析 JDOM 解析 DOM4J 解析 案例实操 DOM 解析 DOM(Document Object Model, 文档对象模型),在应用程序中,基于 DOM 的 XML 分析器将一个 XML 文档转换成一个对象模型的集合(通常称为 DOM 树 ),应用程序正是通过对这个对象模型的操作,来实现对 XML 文档数据的操作.XML 本身是以树状的形式出现的,所以 DOM 操作的时候,也将按章树的形式进行转换.在整个 DOM 树中,最大的地方指的是 Docume

  • Java实现线程安全单例模式的五种方式的示例代码

    目录 饿汉式 枚举单例 懒汉式 DCL 懒汉式 静态内部类懒汉单例 饿汉式 饿汉式:类加载就会导致该单实例对象被创建 // 问题1:为什么加 final // 问题2:如果实现了序列化接口, 还要做什么来防止反序列化破坏单例 public final class Singleton_hungry implements Serializable { // 问题3:为什么设置为私有? 是否能防止反射创建新的实例? private Singleton_hungry(){} // 问题4:这样初始化是否

  • Python中实现单例模式的n种方式和原理

    在Python中如何实现单例模式?这可以说是一个经典的Python面试题了.这回我们讲讲实现Python中实现单例模式的n种方式,和它的原理. 什么是单例模式 维基百科 中说: 单例模式,也叫单子模式,是一种常用的软件设计模式.在应用这个模式时,单例对象的类必须保证只有一个实例存在.许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为.比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获

  • Java四舍五入时保留指定小数位数的五种方式

    方式一: double f = 3.1516; BigDecimal b = new BigDecimal(f); double f1 = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); 输出结果f1为 3.15: 源码解读: public BigDecimal setScale(int newScale, int roundingMode) //int newScale 为小数点后保留的位数, int roundingMode 为变

  • Python实现单例模式的四种方式详解

    简介:单例模式可以保证一个类仅有一个实例,并提供一个访问它的全局访问点.适用性于当类只能有一个实例而且客户可以从一个众所周知的访问点访问它,例如访问数据库.MQ等. 实现方式: 1.通过导入模块实现 2.通过装饰器实现 3.通过使用类实现 4.通过__new__ 方法实现 单例模块方式被导入的源码:singleton.py # -*- coding: utf-8 -*- # time: 2022/5/17 10:31 # file: singleton.py # author: tom # 公众

  • Java中初始化List集合的八种方式汇总

    目录 1.常规方式 2.Arrays 工具类 3.Collections 工具类 4.Lists 工具类 5.匿名内部类 6.ImmutableList 7.Java8 Stream 8.Java9 List.of 总结 List 是在开发中比较常用的集合,今天总结一下 Java 中初始化 List 的几种方式. 1.常规方式 List<String> list = new ArrayList<>(); list.add("1"); list.add("

  • 使用python解析json字段的3种方式实例

    目录 1.运用re.json.jsonpath包解析json思路 2.三种方式的json解析案例 (1)运用re正则表达式解析json (2)运用字典的数据结构性质解析json (3)运用jsonpath的路径解析json 3.附录:re正则表达式语法 附:python 处理非标准 json 格式字符串 总结 1.运用re.json.jsonpath包解析json思路 (1)re:正则表达式,通过json的形式对症下药,写表达式去解析json: (2)json: 通过json中的json.loa

  • javascript解析json数据的3种方式

    3种方式解析json数据 复制代码 代码如下: var obj=eval("("+traItem.rel+")"); //性能不好 var obj = (new Function("return " + traItem.rel))(); var obj = JSON.parse(traItem.rel); //这个要求的格式比较严格

  • Java设计模式常用原则解析

    1.单一职责原则 每一个类负责一个职责(一个类只有一个方法) 2.里氏替换原则 所有引用基类的地方都能透明的使用其子类的对象. 问题来了: 比如原来 class A{ fun();//完成P1功能 } 现在需要添加新功能 class B extends A{//A的子类B实现了fun的功能) fun();完成功能为P(原来的P1功能加上新增的P2功能) } 则,在子类B完成新功能P2的时候可能会导致原有功能P1发生故障 解决办法 当使用继承的时候,除了添加新的方法来完成新功能P2之外,尽量不要重

随机推荐