首页 > 其他分享 >01.单例设计模式

01.单例设计模式

时间:2022-12-07 17:00:42浏览次数:42  
标签:Singleton 01 静态 instance 实例 static 单例 设计模式 public

单例设计模式

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

单例设计模式有八种方式

  1. 饿汉式(静态常量)
  2. 饿汉式(静态代码块)
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全,同步方法)
  5. 懒汉式(线程安全,同步代码块)
  6. 双重检查法
  7. 静态内部类
  8. 枚举

饿汉式(静态常量)

步骤如下:

  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 == instance2);  //true
    }
}


//饿汉式(静态常量)
class Singleton{
    //1、构造器私有化,外部不能直接new
    private Singleton() {

    }

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

    //3、提供一个公共的静态方法,返回实例
    public static Singleton getInstance(){
        return instance;
    }
}

优缺点说明:

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

饿汉式(静态代码块)

步骤如下

  1. 构造器私有化(防止直接 new对象)

  2. 定义一个静态私有的属性,在静态代码块当中完成初始化工作

  3. 向外提供一个静态的公共方法,getInstance()

  4. 代码实现

    public class SingletonTest02 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2); //true
        }
    }
    
    
    //饿汉式(静态常量)
    class Singleton{
        //1、构造器私有化,外部不能直接new
        private Singleton() {
    
        }
    
        //2、本类内部创建对象实例
        private static Singleton instance;
        //在静态代码块当中完成初始化工作
        static {
            instance =  new Singleton();
        }
    
        //3、提供一个公共的静态方法,返回实例
        public static Singleton getInstance(){
            return instance;
        }
    }
    

优缺点说明

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

  2. 结论:这种单例模式可以用,但是会造成内存的浪费

懒汉式(线程不安全)

实现步骤

  1. 构造器私有化(防止直接 new对象)

  2. 定义一静态的私有化对象

  3. 对外提供一个获取实例的方法,当实例为null的时候,new 一个实例

  4. 代码实现

    public class SingletonTest03 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2); //true
        }
    }
    
    
    class Singleton {
        //1、构造器私有化
        public Singleton() {
        }
    
        //2、创建一个私有的静态对象
        private static Singleton instance;
    
    
        //3、提供一个静态的共有方法,当时用到该方法时,才去创建对象
        //这就是懒汉式
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
    

优缺点分析

  1. 起到了懒加载的效果,但是只能在单线程下使用
  2. 如果在多线程下,一个线程进入到了if判断语句块,还未来得及往下执行,另一个线程也通过这个判断语句,这时便会产生多个实例,所以在多线程的情况下不能使用这种方式
  3. 结论:在实际的开发当中,不要使用这种方式

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

实现步骤

  1. 构造器私有化(防止直接 new对象)

  2. 定义一静态的私有化对象

  3. 对外提供一个获取实例的同步方法,当实例为null的时候,new 一个实例

  4. 代码实现

    public class SingletonTest04 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2); //true
        }
    }
    
    class Singleton {
        //1、构造器私有化
        public Singleton() {
        }
    
        //2、创建一个私有的静态对象
        private static Singleton instance;
    
    
        //3、提供一个静态的共有同步方法,当时用到该方法时,才去创建对象
        //这就是懒汉式
        public static synchronized Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }
    }
    

优缺点分析

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

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

实现步骤

  1. 构造器私有化(防止直接 new对象)

  2. 定义一静态的私有化对象

  3. 对外提供一个获取实例的方法,当实例为null的时候,对创建实例的代码块进行同步

  4. 代码实现

    public class SingletonTest05 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2); //true
        }
    }
    
    class Singleton {
        //1、构造器私有化
        public Singleton() {
        }
    
        //2、创建一个私有的静态对象
        private static Singleton instance;
    
    
        //3、提供一个静态的共有同步方法,当时用到该方法时,才去创建对象
        //这就是懒汉式
        public static Singleton getInstance() {
            if (instance == null) {
                //对创建实例的代码块进行同步
                synchronized(Singleton.class){
                    instance = new Singleton();
                }
            }
            return instance;
        }
    }
    

优缺点分析

  1. 这种方式,本意是相对第四种实现方式的改进,因为前面同步方法效率太低,改为同步代码块产生实例化的代码块
  2. 但是这种同步并不能起到线程同步的作用,跟第3中实现方式遇到的情形一致,加入一个线程进入if判断当中,还未来及往下执行。另一个线程也通过了这个判断语句,这时便会产生多个实例
  3. 结论:在实际的开发中,不能使用这种方式

双重检查法

实现步骤

  1. 构造器私有化(防止直接 new对象)

  2. 定义一个静态的使用volatile修饰的私有化对象

  3. 对外提供一个获取实例的方法,实行双重检查创建对象

  4. 代码实现

    public class SingletonTest06 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2); //true
        }
    }
    
    
    class Singleton {
        //1、构造器私有化
        public Singleton() {
        }
    
        //2、创建一个私有的静态对象
        //volatile当值发生修改的时候,立即将值更新到内存当中
        private static volatile Singleton instance;
    
        //3、提供一个静态的公有方法,加入双重检查代码,解决线程
        //安全问题,同时解决了懒加载的问题
        public static Singleton getInstance() {
            if (instance == null) {
                //对创建实例的代码块进行同步
                synchronized(Singleton.class){
                    if (instance == null){
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
    

优缺点分析

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

静态内部类

实现步骤

  1. 构造器私有化(防止直接 new对象)

  2. 定义一个静态内部类

  3. 在静态内部类当中定义一个静态属性

  4. 对外提供一个获取实例的方法,返回静态内部类当中的静态属性

  5. 代码实现

    public class SingletonTest07 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.getInstance();
            Singleton instance2 = Singleton.getInstance();
            System.out.println(instance1 == instance2); //true
        }
    }
    //推荐使用
    class Singleton {
        //1、构造器私有化
        public Singleton() {
        }
    
        //2、创建一个私有的静态对象
        private static Singleton instance;
    
        //写一个静态内部类,该类当中有一个静态属性SingletonInstance
        private static class SingletonSInstance{
            private static final Singleton INSTANCE = new Singleton();
        }
    
        //提供一个静态公有方法,直接返回SingletonSInstance.INSTANCE
    
        public static Singleton getInstance() {
            return SingletonSInstance.INSTANCE;
        }
    }
    

优缺点分析

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

枚举

实现步骤

  1. 定义一个枚举,在枚举当中定义需要的属性和方法

  2. 代码实现

    public class SingletonTest08 {
        public static void main(String[] args) {
            Singleton instance1 = Singleton.INSTANCE;
            Singleton instance2 = Singleton.INSTANCE;
    
            System.out.println(instance1 == instance2);//true
            instance1.sayOK();
        }
    }
    
    
    enum Singleton{
        INSTANCE;
        public void sayOK(){
            System.out.println("hi~~");
        }
    }
    

优缺点分析

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

JDK当中的经典单例模式分析

Runtime就是饿汉式单例模式

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
}

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

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

标签:Singleton,01,静态,instance,实例,static,单例,设计模式,public
From: https://www.cnblogs.com/dbcxy/p/16962721.html

相关文章

  • 《小白WEB安全入门》01. 扫盲篇
    目录基础知识什么是WEB什么是前端什么是后端什么是数据库什么是协议什么是WEB安全什么是服务器什么是IP地址、端口什么是局域网、广域网、内网、外网什么是URL什么是MAC地......
  • 001- hive文件存储格式
    1.文件存储格式TextFileSequeceFileRCFileORCFilePARQuet2.说明其中TEXTFILE为默认格式,导入数据时会直接把数据文件拷贝到hdfs上不进行处理;SequenceFile,RCF......
  • Scrapy入门到放弃01:我为什么选择Scrapy
    前言Scrapyiscoming!!在写了七篇爬虫基础文章之后,终于写到心心念念的Scrapy了。Scrapy开启了爬虫2.0的时代,让爬虫以一种崭新的形式呈现在开发者面前。在18年实习的时候......
  • 大数据杂谈:我和大数据(2017 - 2021)
    前言又是一年乍暖还寒,春天的风迎面而来,凉意中夹杂着些许温暖。哦,你知道,是春天来了。就像那年的实习期,在挥手告别的毕业季,定格在了那年的七月。人会怀念,怀念青涩时期的自......
  • java单例模式
    1.饿汉式2.懒汉式2.1 双重检查2.2 静态内部类2.3 枚举......
  • 【每天一个java设计模式(完)】 - 四万字实现23种设计模式(附示例源码)
    什么是设计模式:​​【每天一个java设计模式(零)】-设计模式基本概念及七大设计原则​​创建型模式工厂模式:​​【每天一个java设计模式(一)】-工厂模式​​抽象工厂模式:......
  • 如何在Windows Server 2016上重置用户“管理员”的密码
    方法来自如何在WindowsServer2016上重置用户“管理员”的密码-AleAdmin.it如果您忘记了装有WindowsServer2016(物理或虚拟)的服务器上的本地管理员密码,则可以从操作......
  • React组件设计模式-纯组件,函数组件,高阶组件
    一、组件(1)函数组件如果你想写的组件只包含一个render方法,并且不包含state,那么使用函数组件就会更简单。我们不需要定义一个继承于React.Component的类,我们可以定......
  • SBT30100VFCT-ASEMI低压降肖特基SBT30100VFCT
    编辑:llSBT30100VFCT-ASEMI低压降肖特基SBT30100VFCT型号:SBT30100VFCT品牌:ASEMI封装:TO-220F正向电流:30A反向电压:100V引线数量:3芯片个数:2芯片尺寸:94MIL漏电流:20ua......
  • 面试时如何聊单例模式
    今天有个我辅助的学员,他今天面试了软通动力Java开发工程,他期望薪资是18k。面试他的正是甲方华为公司。其中面试官要他说说他自己熟悉的设计模式。然后他巴拉巴拉,说了单例模......