单例模式

单例设计模式介绍

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

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

八种实现方式

1）饿汉式（静态常量）

• ​ 步骤：
• 创建构造器私有化
• 本类内部创建对象实例
• 提供公共的静态方法，返回实例 (getInstance)

• ​ 代码实现：

package singleton;

/**
 * @description 生产者
 * @author -还怕大雨吗
 * @date 2021/8/26 9:52
 * @version 1.0
 */
public class SingletonTest2 {
    /***
     * 1、首先构造器私有化。
     */
    private SingletonTest2(){}
    /***
     * 2、本类内部创建对象实例
     */
    private final static SingletonTest2 SINGLETON_TEST_2n = new SingletonTest2();
    /***
     * 3、提供一个公共的静态方法，返回实例
     */
    public static SingletonTest2 getInstance(){
        return SINGLETON_TEST_2n;
    }
}

package singleton;

/**
 * @description 消费者
 * @author -还怕大雨吗
 * @date 2021/8/26 9:46
 * @version 1.0
 */
public class SingletonTest1 {
    public static void main(String[] args) {

        SingletonTest2 instance = SingletonTest2.getInstance();
        SingletonTest2 instance1 = SingletonTest2.getInstance();
        System.out.println("instance1 = " + instance1);
        System.out.println("instance = " + instance);
        System.out.println(instance==instance1);
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
        System.out.println("instance.hashCode() = " + instance.hashCode());
    }


}

//日志
instance1 = singleton.SingletonTest2@4554617c
instance = singleton.SingletonTest2@4554617c
true
instance1.hashCode() = 1163157884
instance.hashCode() = 1163157884

Process finished with exit code 0

​ 优缺点：

• 优点 ： 写法较为简单，就是在类装载的时候就完成了实例化，避免了线程同步的问题
• 缺点： 在类装载的时候就完成了实例化，没有达到Lazy Loading的效果，如果从开始到结束都没有使用到这个实例，则会造成内存浪费
• 这种方式基于ClassLoder机制避免了多线程的同步问题，不过，Instance在类装载的时候就实例化，在单例模式中大多数使用的都是调用GetInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他方式（或者其他的静态方法）导致类装载，这时候初始化Instance就没有达到Lazy Loading的效果
• 这种单例模式可用，也比较简单，**但是可能会造成内存浪费**

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

• 步骤
• 将静态常量赋值换成了静态代码块赋值

• 代码实现

• 与静态常量相比较，换成了静态代码块

package singleton.type2;

/**
 * @description TODO
 * @author -还怕大雨吗
 * @date 2021/8/26 9:52
 * @version 1.0
 */
public class SingletonTest3 {
    /***
     * 1、首先构造器私有化。
     */
    private SingletonTest3(){

    }

    // 在静态代码块中，创建单例对象
    static {
        SINGLETON_TEST_3n  = new SingletonTest3();
    }

    /***
     * 2、本类内部创建对象实例
     */
    private static SingletonTest3 SINGLETON_TEST_3n;


    /***
     * 3、提供一个公共的静态方法，返回实例
     */
    public static SingletonTest3 getInstance(){
        return SINGLETON_TEST_3n;
    }
}

优缺点说明

• 这种方式和静态常量相似，只不过将类实例化的过程放在了静态代码块中，也是在类装在的时候，就执行了静态代码块中的代码，初始化类的实例，优缺点都一样，
• 可用，但是==可能会造成内存浪费==

3）懒汉式（线程不安全–不推荐）

• 基本步骤
• 构造器私有化
• 创建对象实例，
• 提供公共静态方法，判断实例是否被创建，没有被创建的时候才去创建实例
• 优缺点
• 起到了Lazy Loading的效果，但是只能在单线程下使用
• 如果在多线程下，一个线程进入了if语句块，还没来的及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所有不能在多线程下使用
• 在实际开发中不能使用

/***
     * 1、首先构造器私有化。
     */
    private IdlerTest2(){

    }

    /***
     * 2、本类内部创建对象实例
     */
    private static IdlerTest2 idlerTest2;

    /***
     * 3、提供一个公共的静态方法，返回实例
     */
    public static IdlerTest2 getInstance(){
        if (idlerTest2 == null){
            idlerTest2 = new IdlerTest2();
        }
        return idlerTest2;
    }

package singleton.type3;

/**
 * @description TODO
 * @author -还怕大雨吗
 * @date 2021/8/26 14:56
 * @version 1.0
 */
public class IdlerTest1 {
    public static void main(String[] args) {
        IdlerTest2 instance = IdlerTest2.getInstance();
        IdlerTest2 instance1 = IdlerTest2.getInstance();

        System.out.println("比较后 = " + (instance1 == instance));
        System.out.println("instance.hashCode() = " + instance.hashCode());
        System.out.println("instance1.hashCode() = " + instance1.hashCode());
    }


}

比较后 = true
instance.hashCode() = 1163157884
instance1.hashCode() = 1163157884

懒汉式（线程安全。同步方法–不推荐）

• 优缺点
• 比上面的多加了一个 synchronized 锁
• 解决了线程不安全的问题，每个线程想要获取类的实例的时候，执行getInstance方法都要进行同步，而其实这个方法只执行一次就可以了 ，后面的想要获得都是return，方法同步效率太低
• 实际开发不推荐
• 代码实现
  ```
  /***

  • 3、提供一个公共的静态方法，返回实例,给他上锁
    */
    public static synchronized IdlerTest2 getInstance(){
    if (idlerTest2 == null){
    idlerTest2 = new IdlerTest2();
    }
    return idlerTest2;
    }
    ```

    5）懒汉式（线程安全。同步代码块 – 不能使用）

• 优缺点

• 这种方法本意是想要对第四种代码进行改进
• 他会遇到和上面一种一样的问题，也会产生多个实例
• ==不能使用==
• 代码实现
  ```
  /***
  • 3、提供一个公共的静态方法，返回实例,加入同步代码块中，给他上锁
    */
    public static IdlerTest2 getInstance(){
    if (idlerTest2 == null){
    synchronized (IdlerTest2.class){
    idlerTest2 = new IdlerTest2();
    }
    }
    return idlerTest2;
    }
    ```

6）双重检查

• 优缺点
• Double-Check概念是多线程开发中常使用到的，如代码所示，我们进行了两次检查，这样就可以保证线程安全的
• 实例化代码只用执行一次，后面再次访问的时候，判断if的时候，直接return实例化对象，避免反复进行方法同步
• ==线程安全，延迟加载，效率较高==
• 在开发中比较推荐
• 代码实现

 private static volatile IdlerTest2 idlerTest2;
  
/***
     * 3、提供一个公共的静态方法，双重检查，解决线程安全，同时解决懒加载
     */
    public static  IdlerTest2 getInstance(){
        if (idlerTest2 == null){
            synchronized (IdlerTest2.class){
                if (idlerTest2 == null){
                    idlerTest2 = new IdlerTest2();
                }
            }
        }
        return idlerTest2;
    }

7）静态内部类

• 特点
• 当类加在的时候，静态内部类并不会被装配，只有调用静态内部类里方法的时候才会被装配
• 类装配的时候一定是线程安全的，并且只会装载一次
• 优缺点
• 这种方式采用了类装载的机制来保证初始化实例时只有一个线程
• 类的静态属性只会在第一次加在类的时候初始化，所以在这里jvm为我们保证了线程安全，类初始化的时候，别的线程无法进入
• 避免了线程不安全，延迟加载，效率高
• 代码实现

/***
     * 1、首先构造器私有化。
     */
    private IdlerTest2(){

    }

    /***
     * 2、静态内部类
     */
    public static class IdlerTest2Instance{
        private static  IdlerTest2 idlerTest2 = new IdlerTest2();
    }

    /***
     * 3、提供一个公共的静态方法，双重检查
     */
    public static  IdlerTest2 getInstance(){
        return IdlerTest2Instance.idlerTest2;
    }

8）枚举

• 优缺点
• 借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步，而且还能防止反序列化重新创建新的对象
• 是java作者提倡的方式
• 代码实现

package singleton.type3;

import singleton.type2.SingletonTest3;

/**
 * @description TODO
 * @author -还怕大雨吗
 * @date 2021/8/26 14:56
 * @version 1.0
 */
public enum IdlerTest2 {
    IDLERTEST2;

    public void sayOK(){
        System.out.println("oks");
    }

}

  public static void main(String[] args) {
        IdlerTest2 idlertest2 = IdlerTest2.IDLERTEST2;
        IdlerTest2 idlertest21 = IdlerTest2.IDLERTEST2;

        System.out.println("比较后 = " + (idlertest2 == idlertest21));
        System.out.println("idlertest2.hashCode() = " + idlertest2.hashCode());
        System.out.println("idlertest21.hashCode() = " + idlertest21.hashCode());
    }

比较后 = true
idlertest2.hashCode() = 1163157884
idlertest21.hashCode() = 1163157884

在JDK的使用

• 在JDK中，java.lang.Runtime 是经典的单例模式

代码是不是很熟悉

注意事项和细节说明

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

勤能补拙，百炼成钢
更多详情