单例模式

No tag
设计模式
Publish Date:   2022-07-10
Word Count:   2.1k
Read Times:   7 Min
Read Count:  

单例模式

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

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

单例设计模式的8种方式：

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

1.饿汉式（静态常量）

步骤：

  • 构造器私有化（防止通过new创建实例）
  • 类的内部创建对象
  • 向外暴露一个静态的公共方法。getInstance()
/**
 * 饿汉式（静态常量）
 */
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 ） 这 种 方 式 基 于 classloader 机 制 避 免 了 多 线 程 的 同 步 问 题 ， 不 过 ， instance 在 类 装 载 时 就 实 例 化 ， 在 单 例 模 式 中 大 多 数 都 是 调 用 getInstance 方 法 ， 但 是 导 致 类 装 载 的 原 因 有 很 多 种 ， 因 此 不 能 确 定 有 其 他 的 方 式 （ 或 者 其 他 的 静 态 方 法 ） 导 致 类 装 载 ， 这 时 候 初 始 化 instance 就 没 有 达 到 lazy loading 的 效 果 4 ） 结 论 ： 这 种 单 例 模 式 可 用 ， 可 能 造 成 内 存 浪 费

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

/**
 * 饿汉式（静态代码块）
 */
class Singleton{

    //1.构造器私有化，外部不能new
    private Singleton(){

    }

    //2.本类内部创建实例
    private static Singleton instance;

    static {
        instance = new Singleton();
    }
    //3.提供一个公有的静态方法。返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优 缺 点 说 明 ： 1 ） 这 种 方 式 和 上 面 的 方 式 其 实 类 似 ， 只 不 过 将 类 实 例 化 的 过 程 放 在 了 静 态 代 码 块 中 ， 也 是 在 类 装 载 的 时 候 ， 就 执 行 静 态 代 码 块 中 的 代 码 ， 初 始 化 类 的 实 例 。 优 缺 点 和 上 面 是 一 样 的 。 2 ） 结 论 ： 这 种 单 例 模 式 可 用 ， 但 是 可 能 造 成 内 存 浪 费

3.懒汉式（线程不安全）

class Singleton{
    private static Singleton instance;

    private Singleton(){

    }

    //提供静态的公有方法，当使用到该方法时，才去创建instance
    //既懒汉式
    public static Singleton getInstance() {
        if (instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点：

1）起到了lazy loading的效果，但是只能在单线程下使用

2）如果在多线程下，一个线程进入了if(instance == null)判断语句块，还未来得及向下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

3）结论：在实际开发中，不要使用这种方式。

4.懒汉式（线程安全）

在getInstance方法加一个synchronized,解决线程不安全的问题,

//加入了同步代码，解决线程不安全的问题
public static synchronized Singleton getInstance() {
    if (instance == null){
        instance = new Singleton();
    }
    return instance;
}

优缺点：

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

5.懒汉式（同步代码块，但是线程不安全）

为了解决上面懒汉式效率太低的问题，我们使用同步代码块

class Singleton{
    private static Singleton instance;

    private Singleton(){

    }

    public static Singleton getInstance() {
        if (instance == null){
            synchronized (Singleton.class){
                instance = new Singleton();
            }
        }
        return instance;
    }
}

但是这么搞就会出现和第3个例子中同样的线程不安全的问题，假如一个线程进入了if (instance == null)，还未来得及向下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以这种方法更不靠谱。

6.双重检查

volatile:保证可见性，防止指令重排序

理解：

不用volatile的状态： 老板让多个人共同完成一件事（初始状态为进行中），假设其中某一个人完成后，事件状态变成了已完成，但是 其他人不知道这件事已完成，认为该事件依然处于进行中，这就造成了事情的状态与真实状态不同步的现象。使用volatile的状态：老板让多个人共同完成一件事（初始状态为进行中），假设其中某一个人完成后，事件状态变成了已完成；此时其他人立刻从老板那接到了事情已完成的通知，于是都明确了这件事已经完成了。

volatile的作用：每次读取前必须先从主存刷新最新的值。每次写入后必须立即同步回主存当中

二次判空原因

第一次判断是为了验证是否创建对象，判断为了避免不必要的同步 第二次判断是为了避免重复创建单例，因为可能会存在多个线程通过了第一次判断在等待锁，来创建新的实例对象。

class Singleton{
    private static volatile Singleton instance;

    private Singleton(){

    }

    public static Singleton getInstance() {
        if (instance == null){
            synchronized (Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

开发中推荐使用

7.静态内部类

class Singleton{

    private Singleton(){

    }
    public static class SingletonInstance{
        private static final Singleton INSTANCE = new Singleton();
    }

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

8.枚举

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance1 = Singleton.INSTANCE;
        System.out.println(instance == instance1);//true
        System.out.println("instance.hashCode="+instance.hashCode());
        System.out.println("instance1.hashCode="+instance1.hashCode());
        instance.sayOK();
    }
}
//使用枚举，实现单例
enum Singleton{
    INSTANCE;
    public void sayOK(){
        System.out.println("ok");
    }
}
  1. 这是借助JDK1.5中添加的枚举实现单例模式，不仅避免多线程同步问题，而且还能防止反序列化重新创建新的对象
  2. 这种方式是Effective Java作者Josh Bloch 提倡的方式
  3. 结论：推荐使用

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

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

image-20220709235740282

可以看出来是单例饿汉式

  1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想要实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
  3. 单 例 模 式 使 用 的 场 景 ： 需 要 频 繁 的 进 行 创 建 和 销 毁 的 对 象 、 创 建 对 象 时 耗 时 过 多 或 耗 费 资 源 过 多 （ 即 ： 重 量 级 对 象 ） ， 但 又 经 常 用 到 的 对 象 、 工 具 类 对 象 、 频 繁 访 问 数 据 库 或 文 件 的 对 象 （ 比 如 数 据 源 、 session 工 厂 等 ）
Author: qwq小小舒
Link: https://js6288.github.io/2022/07/10/201/
Reprint policy: All articles in this blog are used except for special statements CC BY 4.0 reprint policy. If reproduced, please indicate source qwq小小舒 !
No tag
赏
  TOC