单例模式

迷人的老约翰 2021-09-03 08:30:12 18383 1 0 0

单例模式

单例设计模式介绍

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

比如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 是经典的单例模式

代码是不是很熟悉
图片alt

注意事项和细节说明

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

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