理解单例模式及其IoDH实现

单例模式

1.什么是单例模式？

单例模式的目的是保证一个类里只有一个实例，并提供一个访问它的全局访问点。

2.单例模式的设计方法：

2.1懒汉式：

• 一个私有的构造函数：确保只能由类自身创建实例，不能被外部构造或被子类继承。
• 静态的未实例化的私有成员变量：即该类的实例，确保一个类只能有一个实例。
• 静态的公用工厂方法：全局访问点提供给其他类调用获取实例。

当要使用这个类时，通过该类的工厂方法生成该类的实例，工厂方法会判断实例是否已经存在，存在则返回该实例，否则创建一个实例返回。

public class SingleTon2(){
   private SingleTon2(){
   }
   private static SingleTon2 singleton2 = null;
   public static getInstance(){
     if(singleton2 == null){
	   singleton2 = new SingleTon2();
	 }
	  return singleton2 ;
   }
}

2.2饿汉式：

• 实例化的静态私有成员变量：确保实例不能直接被外界获取。
• 私有的空参构造器：防止系统默认生成公有的空参构造器。
• 静态的共有方法：全局访问点提供给其他类调用获取实例。

public class SingleTon1(){
  private SingleTon1(){
  }
  private static SingleTon1 singleton = new SingleTon1();
  public static getInstance(){
     return singleton ;
  }
}

3.两种设计方法对比

3.1普通的懒汉式单例模式

优点

• 使用对象延迟加载的思想：效率高。

  ？延迟加载：程序启动时并不立即加载资源或者数据，等到马上要使用时再加载。

缺点

• 线程不安全的。

  普通的懒汉式单例模式不具有原子性，当程序中引用多线程时，系统中可能会出现多个单例类的实例对象。这违背了单例模式的初衷。

• 操作比饿汉式复杂

优化

1. 在工厂方法前加上synchronized关键字确保原子性

//除第一次使用，getInstance()需要同步,后面getInstance()不需要同步；每次同步，效率很低。
public class SingleTon3(){
   private SingleTon3(){
   }
   private static SingleTon3 singleton3 = null;
   public synchronized static getInstance(){
     if(singleton3 == null){
	   singleton3 = new SingleTon3();
	 }
	  return singleton3 ;
   }
}

优点：

• 解决单例模式线程安全性问题

缺点：

• 每次获取实例时线程都需要同步，使得效率变低。
• 加锁机制使得获取对象速度较慢

2. 双重校验锁模式

//安全且在多线程情况下能保持高性能。
//实例变量需要加volatile 关键字保证易变可见性
public class SingleTon4{
  private SingleTon4(){
  }
  private volatile static SingleTon4 singleton4 = null;
  public static SingleTon4 getSingleton(){
     if(singleton4 == null){
        synchronized (SingleTon4.class){
          if(singleton4 == null){
 		      singleton4 = new SingleTon3();
 		  }
		}
	 }
	  return singleton4 ;
  }
}

优点：

• 在保证多线程安全情况下能保持较高性能。

缺点:

• 获取实例时需要通过锁机制，导致获取对象速度较慢。

3.2饿汉式单例

优点：

• 线程安全
• 获取对象实例反应速度快

缺点：

• 系统加载时间较长

4.扩展

IoDH（Initialization Demand Holder）实现单例模式

class Singleton {  
    private Singleton() {  
    }  
    private static class HolderClass {  
            private final static Singleton instance = new Singleton();  
    }   
    public static Singleton getInstance() {  
        return HolderClass.instance;  
    }  
}  

优点：

• 实现延迟加载
• 保证线程安全：相当于间接使用饿汉模式，静态内部类一旦被加载就直接创建一个单例实例。
• 不影响系统性能：既不会在程序启动时加载类，也不会在获取对象时进行加锁控制。

缺点

• 与编程语言本身的特性相关，很多面向对象语言不支持IoDH

提问

了解到IoDH这里的时候有一些小小的迷惑，静态内部类实现延迟加载？静态内部类不是程序启动时就加载的吗？带着这个问题自己写了一个小小的测试代码:

public class testStaticClass {
    static class a{
        static {
            System.out.println("静态内部类被加载");
        }
    }
    static {
        System.out.println("静态代码块被加载");
    }

    public static void main(String[] args) {
    }
}

可以看到在运行该程序时静态代码块确实是在程序启动时就被加载，但静态内部类中的静态代码块并没有被加载。为了确认自己的验证，通过查阅书籍了解到：

内部类和静态内部类都是延时加载的，也就是说只有在明确用到内部类时才加载。