深入理解单例模式

我欲只争朝夕

发布于 2023-11-7 11:47

浏览

0收藏

前言

有一些对象其实我们只需要一个，比方说：线程池，缓存，对话框，处理偏好设置和注册表的对象，日志对象，充当打印机，显卡等设备的驱动程序的对象。事实上，这类对象只能有一个实例，如果制造出多个实例，就会导致许多问题产生，例如：程序的行为异常，资源使用过量，或者是不一致的结果

涉及到一些类加载的知识，如果不清楚，可以看一下这篇分享：Java类的加载顺序

单例模式确保一个类只有一个实例，并提供一个全局访问点，实现单例模式的方法是私有化构造函数，通过getInstance()方法实例化对象，并返回这个实例

实现

第一种（懒汉）

按照上面的想法，我们有了第一个实现

// code1
public class Singleton {

   private static Singleton uniqueInstance;

   private Singleton() {}

   public static Singleton getInstance() {
       if (uniqueInstance == null) {
           uniqueInstance = new Singleton();
       }
       return uniqueInstance;
   }
}

当2个线程同时进入getInstance()的if语句里面，会返回2个不同实例，因此这种方式是线程不安全的

// code2
public class Singleton {

   private static Singleton uniqueInstance;

   private Singleton() {}

   public static synchronized Singleton getInstance() {
       if (uniqueInstance == null) {
           uniqueInstance = new Singleton();
       }
       return uniqueInstance;
   }
}

用synchronized修饰可以保证线程安全，但是只有第一次执行此方法时才需要同步，设置好 uniqueInstance，就不需要同步这个方法了，之后每次调用这个方法，同步都是一种累赘

第二种（双重检查锁定）

synchronized锁的粒度太大，人们就想到通过双重检查锁定来降低同步的开销，下面是实例代码

// code3
public class Singleton {

   private static Singleton uniqueInstance;

   private Singleton() {}

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

如上面代码所示，如果第一次检查uniqueInstance不为null，那么就不需要执行下面的加锁和初始化操作，可以大幅降低synchronized带来的性能开销，只有在多个线程试图在同一时间创建对象时，会通过加锁来保证只有一个线程能创建对象

双重检查锁定看起来似乎很完美，但这是一个错误的优化！在线程执行到getInstance()方法的第4行，代码读取到uniqueInstance不为null时，uniqueInstance引用的对象有可能还没有完成初始化

简单概述一下《Java并发编程的艺术》的解释， uniqueInstance = new Singleton()可以分解为如下三行伪代码

memory = allocate();    // 1:分配对象的内存空间
ctorInstance(memory);   // 2:初始化对象
uniqueInstance = memory;// 3:设置uniqueInstance指向刚分配的内存地址

3行伪代码中的2和3之间，可能会被重排序，重排序后执行时序如下

memory = allocate();    // 1:分配对象的内存空间
uniqueInstance = memory;// 3:设置uniqueInstance指向刚分配的内存地址
                       // 注意，此时对象还没有被初始化
ctorInstance(memory);   // 2:初始化对象

多个线程访问时可能出现如下情况

深入理解单例模式-鸿蒙开发者社区

这样会导致线程B访问到一个还未初始化的对象，此时可以用volatile来修饰Singleton，这样3行伪代码中的2和3之间的重排序，在多线程环境中将会被禁止

// code4
public class Singleton {

   private volatile static Singleton uniqueInstance;

   private Singleton() {}

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

第三种（饿汉）

如果应用程序总是创建并使用单例式例，或者在创建和运行时方面的负担不太繁重，我们可以以饿汉式的方式来创建单例

// code5
public class Singleton {

   private static Singleton uniqueInstance = new Singleton();

   private Singleton() {}

   public static Singleton getInstance() {
       return uniqueInstance;
   }
}

// code6
public class Singleton {

   private static Singleton uniqueInstance;

   static {
       uniqueInstance = new Singleton();
   }

   private Singleton() {}

   public static Singleton getInstance() {
       return uniqueInstance;
   }
}

在类加载的时候直接创建这个对象，这样既能提高效率，又能保证线程安全，code5和code6几乎没有区别，因为静态成员变量和静态代码块都是类初始化的时候被加载

第四种（静态内部类）

// code7
public class Singleton {

   private static class SingletonHolder {
       private static Singleton uniqueInstance = new Singleton();
   }

   private Singleton() {}

   public static Singleton getInstance() {
       return SingletonHolder.uniqueInstance;
   }
}

饿汉式的方式只要Singleton类被装载了，那么uniqueInstance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，uniqueInstance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化uniqueInstance

第五种（枚举）

// code8
public enum Singleton {  
  INSTANCE;  
  public void whateverMethod() {  
  }  
}

公认的实现单例的最好方式，网上资料也比较少，还没有彻底理解清楚，说不定以后会补一篇文章说明，本篇文章中的code1和code3不建议使用，原因已经说明

参考书籍

《Java并发编程的艺术》

《Head First设计模式》

文章转载自公众号：Java识堂

分类

其他

标签

java

已于2023-11-7 11:47:09修改

51CTO

51CTO博客

51CTO学堂