设计模式系列-单例模式

单例模式的作用:

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

单例模式常见的应用场景

(1)Windows系统的任务管理器，回收站。
(2)项目中读取文件配置的类，网站计数器等。
(3)应用程序的日志应用。
(4)数据库连接池的设计
(5)Servlet编程中的每一个Servlet，Spring中ApllicationContext，每一个Bean，以及SpringMVC中的控制器对象等
……

单例模式的优点

(1)单例模式只生成一个实例，减少了系统性能开销。当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决.
(2)单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

常见五种单例模式的实现

(1)主要
饿汉式(线程安全，调用效率高，但不能延时加载)
懒汉式(线程安全，资源利用率高，调用效率不高，但是可以实现延时加载)
(2)其他
双重检测锁式(由于JVM底层内部模型原因，偶尔会出现问题，不建议使用)
静态内部类式(线程安全，调用效率高，可以实现延时加载)
枚举单例(线程安全，调用效率高，不能实现延时加载)

饿汉式实现

public class SingletonDemo1 {

    //类初始化时，立即加载这个对象（没有延时加载的优势）。加载类时，天然的是线程安全的！
    private static SingletonDemo1 instance = new SingletonDemo1();  

    private SingletonDemo1(){
    }
    //虚拟机保证只会装载一次类，肯定不会发生并发访问的问题，不用加上synchronized关键字
    //方法没有同步，调用效率高！
    public static SingletonDemo1  getInstance(){
        return instance;
    }
}

懒汉式实现

public class SingletonDemo2 {

    //类初始化时，不初始化这个对象（延时加载，真正用的时候再创建）。
    private static SingletonDemo2 instance;  

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

    //方法同步，调用效率低！
    public static  synchronized SingletonDemo2  getInstance(){
        if(instance==null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

双重检测锁式实现

由于JVM底层不支持，运行时很可能出问题。一般不会使用，仅仅了解即可

public class SingletonDemo3 { 

  private static SingletonDemo3 instance = null; 

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

  private SingletonDemo3() { 

  } 

}

静态内部类式

外部类没有static属性，不会像饿汉式那样立即加载对象。当调用getInstance()才会加载静态内部类，是线程安全的，兼顾并发高效调用和延时加载的优势，在框架的编写中经常使用。

public class SingletonDemo4 {

    private static class SingletonClassInstance {
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }

    private SingletonDemo4(){
    }

    //方法没有同步，调用效率高！
    public static SingletonDemo4  getInstance(){
        return SingletonClassInstance.instance;
    }

}

枚举单例实现

实现简单，由JVM提供支持，可以避免反射和反序列化的漏洞，缺点是不能实现延迟加载。

public enum SingletonDemo5 {

    //这个枚举元素，本身就是单例对象！
    INSTANCE;

    //添加自己需要的操作！
    public void singletonOperation(){
    }
}

怎么选用哪种实现在项目中使用呢?
如果单例对象占用资源少，不需要延时加载，枚举式好于饿汉式；如果单例对象占用资源大，需要延时加载，静态内部类式好于懒汉式。

反射对单例模式的破解

除了有JVM支持的枚举式单例之外，其他实现方式均可以使用反射和反序列化破解。可以通过readResolve()来解决:

    //反序列化时，如果定义了readResolve()则直接返回此方法指定的对象。而不需要单独再创建新对象！
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }

参考:https://www.youtube.com/watch?v=eQfQLmIP7cI&t=7s