今天在干嘛
设计模式——单例模式
MoMo Lv5
  2024-06-16 16:51:34   2024-06-16 17:17:17    

单例模式

模式说明

实现1个类只有1个实例化对象 & 提供一个全局访问点

作用（解决的问题）

保证1个类只有1个对象，降低对象之间的耦合度

工作原理

在Java中，我们通过使用对象（类实例化后）来操作这些类，类实例化是通过它的构造方法进行的，要是想实现一个类只有一个实例化对象，就要对类的构造方法下功夫：

image

单例模式的一般实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Singleton {

  //1. 创建私有变量 ourInstance（用以记录 Singleton 的唯一实例）
  //2. 内部进行实例化
  private static Singleton ourInstance  = new  Singleton();

  //3. 把类的构造方法私有化，不让外部调用构造方法实例化
  private Singleton() {}

  //4. 定义公有方法提供该类的全局唯一访问点
  //5. 外部通过调用getInstance()方法来返回唯一的实例
  public static  Singleton newInstance() {
      return ourInstance;
  }
}

举例

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
31
32
33
34
35
36
37
38
39
40
41

//单例仓库类
class StoreHouse {

    //仓库商品数量
    private int quantity = 100;
    //自己在内部实例化
    private static StoreHouse ourInstance  = new StoreHouse();;
    //让外部通过调用getInstance()方法来返回唯一的实例。
    public static StoreHouse getInstance() {
        return ourInstance;
    }

    //封闭构造函数
    private StoreHouse() {}

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public int getQuantity() {
        return quantity;
    }
}


//搬货工人类
class Carrier{
    public StoreHouse mStoreHouse;
    public Carrier(StoreHouse storeHouse){
        mStoreHouse = storeHouse;
    }
    //搬货进仓库
    public void MoveIn(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i);
    }
    //搬货出仓库
    public void MoveOut(int i){
        mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i);
    }
}

特点

优点

  • 提供了对唯一实例的受控访问
  • 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能
  • 可以根据实际情况需要，在单例模式的基础上扩展做出双例模式，多例模式

缺点

  1. 单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”
  2. 如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，这将导致对象状态的丢失

单例模式的实现方式

单例模式的实现方式有多种，根据需求场景，可分为2大类、6种实现方式：

image

初始化单例类时 即 创建单例

饿汉式

这是最简单的单例实现方式

  • 原理：依赖 JVM类加载机制，保证单例只会被创建1次，即 线程安全
  1. JVM在类的初始化阶段(即 在Class被加载后、被线程使用前)，会执行类的初始化
  2. 在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化
  • 具体实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Singleton {

    // 1. 加载该类时，单例就会自动被创建
    private static  Singleton ourInstance  = new  Singleton();
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {}
    
    // 3. 通过调用静态方法获得创建的单例
    public static  Singleton newInstance() {
        return ourInstance;
    }
}
  • 应用场景
    除了初始化单例类时 即 创建单例外，继续延伸出来的是：单例对象 要求初始化速度快 & 占用内存小

枚举类型

  • 原理：根据枚举类型的下述特点，满足单例模式所需的 创建单例、线程安全、实现简洁的需求

image

实现方式

1
2
3
4
5
6
7
8
9
10
11
12
public enum Singleton{

    //定义1个枚举的元素，即为单例类的1个实例
    INSTANCE;

    // 隐藏了1个空的、私有的 构造方法
    // private Singleton () {}

}

// 获取单例的方式：
Singleton singleton = Singleton.INSTANCE;
  • 这是 最简洁、易用 的单例实现方式，单元素的枚举类型已经成为实现 Singleton的最佳方法

按需、延迟创建单例

懒汉式（基础实现）

  • 原理：与 饿汉式 最大的区别是：单例创建的时机
  • 饿汉式：单例创建时机不可控，即类加载时 自动创建 单例
  • 懒汉式：单例创建时机可控，即有需要时，才 手动创建 单例
  • 具体实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Singleton {
    // 1. 类加载时，先不自动创建单例
   //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；

    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {}
    
    // 3. 需要时才手动调用 newInstance（） 创建 单例   
    public static  Singleton newInstance() {
    // 先判断单例是否为空，以避免重复创建
    if( ourInstance == null){
        ourInstance = new Singleton();
        }
        return ourInstance;
    }
}
  • 缺点:基础实现的懒汉式是线程不安全的

image

同步锁（懒汉式的改进）

  • 原理：使用同步锁 synchronized锁住 创建单例的方法 ，防止多个线程同时调用，从而避免造成单例被多次创建

    • 即，getInstance（）方法块只能运行在1个线程中
    • 若该段代码已在1个线程中运行，另外1个线程试图运行该块代码，则 会被阻塞而一直等待
    • 而在这个线程安全的方法里我们实现了单例的创建，保证了多线程模式下 单例对象的唯一性

  • 具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 写法1
class Singleton {
    // 1. 类加载时，先不自动创建单例
    //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；
    
    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {}
    
// 3. 加入同步锁
public static synchronized Singleton getInstance(){
        // 先判断单例是否为空，以避免重复创建
        if ( ourInstance == null )
            ourInstance = new Singleton();
        return ourInstance;
    }
}
  • 缺点：每次访问都要进行线程同步（即 调用synchronized锁)，造成过多的同步开销（加锁 = 耗时、耗能）
  • 实际上只需在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步

双重校验锁（懒汉式的改进）

  • 原理：在同步锁的基础上，添加1层 if判断：若单例已创建，则不需再执行加锁操作就可获取实例，从而提高性能

具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Singleton {
    private static  Singleton ourInstance  = null；

    private Singleton() {}
    
    public static  Singleton newInstance() {
      // 加入双重校验锁
      // 校验锁1，防止多次加锁：第1个if
      if( ourInstance == null){  // ①
      synchronized (Singleton.class){ // ②
          // 校验锁2，防止多次创建实例：第2个 if
          if( ourInstance == null){
              ourInstance = new Singleton();
          }
        }
      }
      return ourInstance;
   }
}

说明

  • 校验锁1：第1个if
    • 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作
    • 直接跳到执行 return ourInstance
  • 校验锁2：第2个 if
    • 作用：防止多次创建单例问题
    • 原理
      • 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance()
      • 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕
      • 当线程A释放同步锁时，单例已创建，即instance已非空
      • 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例

缺点
实现复杂 = 多种判断，易出错

静态内部类

原理：

根据 静态内部类 的特性，同时解决了按需加载、线程安全的问题，同时实现简洁

  • 在静态内部类里创建单例，在装载该内部类时才会去创建单例
  • 线程安全：类是由 JVM加载，而JVM只会加载1遍，保证只有1个单例

具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Singleton {
    
    // 1. 创建静态内部类
    private static class Singleton2 {
       // 在静态内部类里创建单例
      private static  Singleton ourInstance  = new Singleton()；
    }

    // 私有构造函数
    private Singleton() {}
    
    // 延迟加载、按需创建
    public static  Singleton newInstance() {
        return Singleton2.ourInstance;
    }

}

说明

  1. 外部调用类的newInstance()
  2. 自动调用Singleton2.ourInstance
    1. 此时单例类Singleton2得到初始化
    2. 而该类在装载 & 被初始化时，会初始化它的静态域，从而创建单例；
    3. 由于是静态域，因此只会JVM只会加载1遍，Java虚拟机保证了线程安全性
  3. 最终只创建1个单例

6. 总结

image

  1. 1. 单例模式
    1. 1.1. 模式说明
    2. 1.2. 作用（解决的问题）
    3. 1.3. 工作原理
  2. 2. 举例
  3. 3. 特点
    1. 3.1. 优点
    2. 3.2. 缺点
  4. 4. 单例模式的实现方式
    1. 4.1. 初始化单例类时 即 创建单例
      1. 4.1.1. 饿汉式
      2. 4.1.2. 枚举类型
    2. 4.2. 按需、延迟创建单例
      1. 4.2.1. 懒汉式（基础实现）
      2. 4.2.2. 同步锁（懒汉式的改进）
      3. 4.2.3. 双重校验锁（懒汉式的改进）
      4. 4.2.4. 静态内部类
  5. 5. 6. 总结
© 2023 - 2025    MoMo
Powered by Hexo & Theme Keep
Unique Visitor Page View
  1. 1. 单例模式
    1. 1.1. 模式说明
    2. 1.2. 作用（解决的问题）
    3. 1.3. 工作原理
  2. 2. 举例
  3. 3. 特点
    1. 3.1. 优点
    2. 3.2. 缺点
  4. 4. 单例模式的实现方式
    1. 4.1. 初始化单例类时 即 创建单例
      1. 4.1.1. 饿汉式
      2. 4.1.2. 枚举类型
    2. 4.2. 按需、延迟创建单例
      1. 4.2.1. 懒汉式（基础实现）
      2. 4.2.2. 同步锁（懒汉式的改进）
      3. 4.2.3. 双重校验锁（懒汉式的改进）
      4. 4.2.4. 静态内部类
  5. 5. 6. 总结