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

    设计模式学习笔记 - 单例设计模式


     

    一、设计模式简介

     
    设计模式（Design pattern）是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式不是代码，而是某类问题的通用解决方案，设计模式代表了最佳的实践。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

    设计模式并不局限于某种语言，java、php、c++都有设计模式。

    设计模式的本质提高软件的维护性，通用性和扩展性，并降低软件的复杂度。

    <<设计模式>> 是经典的书，作者是Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design（俗称 “四人组 GOF”）。

    设计模式分为三种类型，共23种：

    • （1）创建型模式（创建层面上）：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。
    • （2）结构型模式（结构层面上）：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
    • （3）行为型模式（方法层面上）：模版方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式（责任链模式）。
       

    二、单例设计模式

     

    1、单例模式简介

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

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

    单例设计模式有八种方式：
    （1）饿汉式（静态常量）
    （2）饿汉式（静态代码块）
    （3）懒汉式（线程不安全）
    （4）懒汉式（线程安全，同步方法）
    （5）懒汉式（线程安全，同步代码块）
    （6）双重检查
    （7）静态内部类
    （8）枚举
     

    2、实现方式

    2.1 饿汉式（静态常量）

    实现步骤：
    （1）将构造器私有化（防止外部使用构造方法创建对象）。
    （2）在类的内部创建对象。
    （3）向外部暴露一个静态的公共方法，返回实例对象。

    代码实现：

    package com.etc.design.singleton;

public class SingletonTest01  {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}
//饿汉式(静态变量)
class Singleton {
    //1、构造器私有化（防止外部使用构造方法创建对象）。
    private Singleton() {}
    //2、在类的内部创建对象。
    private final static Singleton instance = new Singleton();
    //3. 提供一个公有的静态方法，返回实例对象。
    public static Singleton getInstance() {
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述
     
    优缺点说明：
    （1）优点：这种写法比较简单，在类装载的时候就完成实例化，避免了线程同步问题。
    （2）缺点：在类装载的时候就完成实例化，没有达到懒加载（Lazy Loading）的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
    （3）这种方式基于classloder机制避免了多线程的同步问题。不过，instance在类装载时就实例化，在单例模式中instance大多数都是调用getInstance方法时进行实例化的，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到懒加载（Lazy Loading）的效果。
    （4）结论：饿汉式（静态常量）单例模式可用，但是可能造成内存浪费。
     

    2.2 饿汉式（静态代码块）

    实现步骤：
    （1）将构造器私有化（防止外部使用构造方法创建对象）。
    （2）本类内部先声明实例对象，再在静态代码块中创建单例对象。
    （3）向外部暴露一个静态的公共方法，返回实例对象。

    代码实现：

    package com.etc.design.singleton.type2;

public class SingletonTest02 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}
// 饿汉式（静态代码块）
class Singleton {
    // 1、构造器私有化（防止外部使用构造方法创建对象）。
    private Singleton() {
    }
    // 2、本类内部先声明对象实例。
    private static Singleton instance;
    // 3、再在静态代码块中创建单例对象。
    static {
        instance = new Singleton();
    }
    // 4、提供一个公有的静态方法，返回实例对象。
    public static Singleton getInstance() {
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    在这里插入图片描述
     
    优缺点说明：
    （1）优缺点和饿汉式（静态常量）的单例模式是一样的。
    （2）饿汉式（静态代码块）的单例模式和饿汉式（静态常量）的单例模式类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候执行静态代码块中的代码，初始化类的实例。
    （3）结论：饿汉式（静态代码块）的单例模式可用，但是可能造成内存浪费。
     

    2.3 懒汉式（线程不安全）

    实现步骤：
    （1）将构造器私有化（防止外部使用构造方法创建对象）。
    （2）本类内部先声明实例对象。
    （3）向外部暴露一个静态的公共方法，当使用到该方法时，才去创建实例对象，并返回该实例对象。

    代码实现：

    package com.etc.design.singleton.type3;

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

class Singleton {
    // 本类内部先声明实例对象。
    private static Singleton instance;
	// 构造器私有化（防止外部使用构造方法创建对象）。
    private Singleton() {}
    // 向外部暴露一个静态的公共方法，当使用到该方法时，才去创建实例对象，并返回该实例对象。
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    在这里插入图片描述
     
    优缺点说明：
    （1）起到了懒加载（Lazy Loading）的效果，但是只能在单线程下使用。
    （2）如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还没来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
    （3）结论：在实际开发中，不要使用这种方式。
     

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

    实现步骤：
    （1）将构造器私有化（防止外部使用构造方法创建对象）。
    （2）本类内部先声明实例对象。
    （3）向外部暴露一个静态的公共方法，当使用到该方法时，才去创建实例对象，并返回该实例对象。加入同步处理的代码（synchronized关键字），解决线程安全问题

    代码实现：

    package com.etc.design.singleton.type4;

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

class Singleton {
    // 本类内部先声明实例对象。
    private static Singleton instance;
    // 构造器私有化（防止外部使用构造方法创建对象）。
    private Singleton() {}
    // 向外部暴露一个静态的公共方法，当使用到该方法时，才去创建实例对象，并返回该实例对象。
    // 加入同步处理的代码（synchronized关键字），解决线程安全问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这里插入图片描述
     
    优缺点说明：
    （1）优点：解决了线程安全问题。
    （2）缺点：方法效率太低，每个线程在想获得类的实例时，执行getInstance()方法都要进行同步。而这个方法其实只执行一次实例化代码就可以了，后面的想获得该类的实例，直接return即可。
    （3）结论：在实际开发中，不推荐使用这种方式。
     

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

    代码实现：

    package com.etc.design.singleton.type5;

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

class Singleton {
    // 本类内部先声明实例对象。
    private static Singleton instance;
    // 构造器私有化（防止外部使用构造方法创建对象）。
    private Singleton() {}
    // 向外部暴露一个静态的公共方法，当使用到该方法时，才去创建实例对象，并返回该实例对象。
    public static  Singleton getInstance() {
        if (instance == null) {
            // 这种同步代码块并不能起到线程同步的作用
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

     
    优缺点说明 ：
    （1）这种懒汉式（线程安全，同步代码块）的方式本意是想对懒汉式（线程安全，同步方法）的方式进行改进。因为懒汉式（线程安全，同步方法）同步方法的效率太低， 所以改成同步 产生实例化的代码块，但是这种同步并不能起到线程同步的作用，跟懒汉式（线程不安全）的方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块， 还没有来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
    （3）结论：在实际开发中，不能使用这种方式。
     

    2.6 双重检查（推荐使用）

    代码实现：

    package com.etc.design.singleton.type6;

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

class Singleton {
    // 本类内部先声明实例对象。
    private static volatile Singleton instance;
    // 构造器私有化（防止外部使用构造方法创建对象）。
    private Singleton() {}
    // 提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题。
    // 同时保证了效率, 推荐使用。
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    volatile关键字的作用主要有：
（1）线程的可见性：当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。
（2）顺序一致性：禁止指令重排序。

    • 1
    • 2
    • 3

    在这里插入图片描述
     
    优缺点说明：
    （1）双重检查（Double-Check）概念是多线程开发中常使用到的，如代码中所示，进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
    （2）实例化对象代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接 return 实例化对象，避免反复的进行方法同步。
    （3）优点：线程安全、延迟加载、效率较高。
    （4）结论：在实际开发中，推荐使用双重检查单例设计模式。
     

    2.7 静态内部类（推荐使用）

    代码实现：

    package com.etc.design.singleton.type7;

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

class Singleton {
    // 构造器私有化
    private Singleton() {}
    // 静态内部类SingletonInstance，该类中有一个静态属性Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    // 提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    在这里插入图片描述
     
    优缺点说明：
    （1）静态内部类方式采用了类装载的机制来保证初始化实例时只有一个线程。类的静态属性只会在第一次加载类的时候初始化，JVM保证了线程的安全性，所以在类进行初始化时，别的线程是无法进入的。
    （2）静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
    （3）优点：避免了线程不安全，利用静态内部类特点实现延迟加载和效率高。
    （4）结论：在实际开发中，推荐使用静态内部类单例设计模式。
     

    2.8 枚举（推荐使用）

    代码实现：

    package com.etc.design.singleton.type8;

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

// 使用枚举，可以实现单例，推荐使用
enum Singleton {
    // 属性
    INSTANCE;
    // 方法
    public void sayOK() {
        System.out.println("ok");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述
     
    优缺点说明：
    （1）枚举的单例模式是Effective Java作者 Josh Bloch提倡的方式。
    （2）单例模式借助 JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
    （3）结论：推荐使用枚举的单例模式。
     

    3、单例模式在JDK应用的源码

    JDK中的java.lang.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 Runtime are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the Runtime 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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

     

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

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

  • 相关阅读:
    9.前端笔记-CSS-CSS三大特性
    vr虚拟现实技术融入司法办案实操培训中的优势
    阿里大于发送短信(用户微服务--消息微服务)
    SpringCloudSleuth异步线程支持和传递
    10个Python脚本来自动化你的日常任务
    大端和小端模式
    TCP通信实战：模拟BS系统
    计算机网络八股文
    CentOS安装Elasticsearch集群
    Python 采集109个中国风风格PPT
  • 原文地址：https://blog.csdn.net/qq_42141141/article/details/127135707