详谈设计-单例模式全网最详解读

简介

单例模式是设计模式中最简单且常用的设计模式。是指确保一个类在任何情况下都绝对只有一个实例，并 提供一个全局访问点。Spring 框架应用中 ApplicationContext；数据库的连接 池也都是单例形式。

1.饿汉模式

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，因为在线程还没出现以前就是实例化了，不可能存在访问安全问题。
优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，占着茅坑不拉屎。
Spring 中 IOC 容器 ApplicationContext 本身就是典型的饿汉式单例。
来看饿汉模式代码：

public class HungrySingleton {
     
   /**
    * 构造器私有化
    */
   private HungrySingleton() {
     }

   /**
    * 静态初始化
    */
   private static final HungrySingleton hungrySingleton=new HungrySingleton();

   /**
    * 提供对外的访问方法
    */
   public static HungrySingleton getInstance(){
     
       return hungrySingleton;
   }
}

2.懒汉模式

懒汉式单例模式：被外部类调用的时候内部类才会加载

2.1 简单实现

先看一下懒汉模式的简单实现，思考一下有什么弊端。

public class LazySimpleSingleton {
     
 /**
  * 构造器私有化
  */
 private LazySimpleSingleton() {
     }

 /**
  * 静态代码，使用公共内存区域
  */
 private static LazySimpleSingleton lazy=null;

 /**
  * 提供对外的访问方法
  */
 public static LazySimpleSingleton getInstance(){
     
     if(lazy==null){
     
         lazy=new LazySimpleSingleton();
     }
     return lazy;
 }
}

有没有同学思考过？这样的写法是线程不安全的。
我们来设想一个极端的例子，假设lazy没有被实例化，多线程环境下10个线程同时进入if判断如下图：
此时多个线程都会执行到new LazySimpleSingleton()方法，产生多个实例，与单例模式的概念相违背，所以说它线程不安全。

2.2 线程安全-懒汉模式

所以，我们需要优化代码，使得懒汉式单例在多线程环境下安全

/**
     * 只需要修改get提供对外的访问方法 
     * 加上synchronized 关键字，使这个方法变成线程同步方法
     */
    public static synchronized LazySingleton getInstance(){
     
        if(lazy==null){
     
            lazy=new LazySingleton();
        }
        return lazy;
    }

加上synchronized 关键字后，会阻塞其他线程调用，防止多个线程同时调用。
虽然目前线程安全了，但在线程数量较多时，会导致大量的线程阻塞，程序的性能必定严重下滑。

2.3 双重锁检查-懒汉模式

那么，有没有一种更好的方式，既 兼顾线程安全又提升程序性能呢？答案是肯定的。我们来看双重检查锁的单例模式

public class LazyDoubleLockCheckSingleton {
     
    /**
     * 构造器私有化
     */
    private LazyDoubleLockCheckSingleton() {
     }

    /**
     * 静态代码，使用公共内存区域
     */
    private static LazyDoubleLockCheckSingleton lazy=null;

    /**
     * 提供对外的访问方法
     */
    public static LazyDoubleLockCheckSingleton getInstance(){
     
       //先判断lazy是否为实例化，没有的话上锁，如果有实例化对象就不必加锁提高效率。
        if(lazy==null){
     
            //这里可能同时有多个线程等待锁,例如线程1获得锁，初始化没完成，lazy==null，线程2.3会进入等待锁。
           synchronized (LazyDoubleLockCheckSingleton.class){
     
               //二次判断的原因，例如线程1执行完成。已经实例化lazy
               //线程2获得锁，如过没加判断会二次实例化对象。
               if(lazy==null){
     
                   lazy=new LazyDoubleLockCheckSingleton();
               }
           }
        }
        return lazy;
    }

2.4 静态内部类-懒汉模式

双重锁虽然保证了线程的绝对安全，但是 synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。所以从类初始化角度来考虑，看下面的代码，采用静态内部类的方式：

public class LazyStaticClassSingleton {
     

    /**
     * 构造器私有化
     */
    private LazyStaticClassSingleton() {
     }

    /**
     * 提供对外的访问方法
     * static 是为了使单例的空间共享 final 保证这个方法不会被重写，重载
     */
    public static final LazyStaticClassSingleton getInstance(){
     
        return LazyStaticClass.Lazy;
    }

    /**
     *  默认认不加载，静态内部类的机制
     */
    private static class  LazyStaticClass{
     
        private static final LazyStaticClassSingleton Lazy=new LazyStaticClassSingleton();
    }
}

静态内部类的优点是：外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化，故而不占内存。 LazyStaticClassSingleton 第一次被加载时，并不需要去加载LazyStaticClass，只有当getInstance()方法第一次被调用时，才会去初始化,第一次调用getInstance()方法会导致虚拟机加载LazyStaticClass类，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

3.防止单例的破坏

3.1 反射会破坏单例模式

了解反射的同学可能发现了（点击查看反射详解），我们上面的代码构造方法里面没有做任何处理。这样的话可以通过反射去破坏单例模式，产生多个实例。
我们以**双重锁模式为例.**请看下列代码

  /**
     * 反射破坏单例模式，产生多个实例
     */
    public static void reflectDestroy() throws Exception{
     
        //获取class对象
        Class<?> clazz= LazyDoubleLockCheckSingleton.class;
        //获取私有构造器
        Constructor<?> constructor = clazz.getDeclaredConstructor(null);
        //设置为true才能获取私有属性
        constructor.setAccessible(true);
        //暴力初始化
        LazyDoubleLockCheckSingleton o = (LazyDoubleLockCheckSingleton)constructor.newInstance();
    //双重锁单例模式
   LazyDoubleLockCheckSingleton singletion = LazyDoubleLockCheckSingleton.getInstance();
   
        System.err.println(singletion);
        System.err.println(o);
        System.err.println(o==singletion);

    }

可以看到两个对象地址不一致，输出为false 单例模式被破坏