① 设计模式的艺术-01.单例（Singleton）模式

单例模式为什么要出现

　　在工做过程当中，发现全部可使用单例模式的类都有一个共性，那就是这个类没有本身的状态，换句话说，这些类不管你实例化多少个，其实都是同样的。

　　若是咱们不将这个类控制成单例的结构，应用中就会存在不少如出一辙的类实例，这会很是浪费系统的内存资源，并且容易致使错误甚至必定会产生错误，

因此咱们单例模式所期待的目标或者说使用它的目的，是为了尽量的节约内存空间，减小无谓的GC消耗，而且使应用能够正常运做。

常见应用场景

　　Windows的Task Manager（任务管理器）就是很典型的单例模式

　　windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程当中，回收站一直维护着仅有的一个实例。

　　项目中，读取配置文件的类，通常也只有一个对象。没有必要每次使用配置文件数据，每次new一个对象去读取。

　　网站的计数器，通常也是采用单例模式实现，不然难以同步。

　　应用程序的日志应用，通常都何用单例模式实现，这通常是因为共享的日志文件一直处于打开状态，由于只能有一个实例去操做，不然内容很差追加。

　　数据库链接池的设计通常也是采用单例模式，由于数据库链接是一种数据库资源。

　　操做系统的文件系统，也是大的单例模式实现的具体例子，一个操做系统只能有一个文件系统。

　　Application 也是单例的典型应用（Servlet编程中会涉及到）

　　在Spring中，每一个Bean默认就是单例的，这样作的优势是Spring容器能够管理

　　在servlet编程中，每一个Servlet也是单例

　　在spring MVC框架/struts1框架中，控制器对象也是单例

单例模式的优势

　　因为单例模式只生成一个实例，减小了系统性能开销，当一个对象的产生须要比较多的资源时，如读取配置、产生其余依赖对象时，则能够经过在应用启动时直接产生一个单例对象，而后永久驻留内存的方式来解决单例模式能够在系统设置全局的访问点，优化环共享资源访问，例如能够设计一个单例类，负责全部数据表的映射处理。

1、饿汉式实现（单例对象当即加载）

public class SingletonDemo1 {
    
    //类初始化时，当即加载这个对象（没有延时加载的优点）。加载类时，自然的是线程安全的！
    private static SingletonDemo1 instance = new SingletonDemo1();  
    
    private SingletonDemo1(){
    }
    
    //方法没有同步，调用效率高！
    public static SingletonDemo1  getInstance(){
        return instance;
    }
    
}

饿汉式单例模式代码中，static变量会在类装载时初始化，此时也不会涉及多个线程对象访问该对象的问题。虚拟机保证只会装载一次该类，确定不会发生并发访问的问题。

所以，能够省略synchronized关键字。

问题：若是只是加载本类，而不是要调用getInstance()，甚至永远没有调用，则会形成资源浪费！

2、懒汉式实现（单例对象延迟加载）

public class SingletonDemo2 {
    
    //类初始化时，不初始化这个对象（延时加载，真正用的时候再建立）。
    private static SingletonDemo2 instance;  
    
    private SingletonDemo2(){ //私有化构造器
    }
    
    //方法同步，调用效率低！
    public static  synchronized SingletonDemo2  getInstance(){
        if(instance==null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
    
}

要点：
    lazy load! 延迟加载， 懒加载！ 真正用的时候才加载！
问题：
    资源利用率高了。可是，每次调用getInstance()方法都要同步，并发效率较低。

 3、双重检查锁实现单例模式

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() { 

  } 
    
}

这个模式将同步内容下方到if内部，提升了执行的效率没必要每次获取对象时都进行同步，只有第一次才同步建立了之后就不必了。

问题：

因为编译器优化缘由和JVM底层内部模型缘由，

偶尔会出问题。不建议使用。

4、静态内部类实现方式(也是一种懒加载方式)

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

要点：

外部类没有static属性，则不会像饿汉式那样当即加载对象。

只有真正调用getInstance(),才会加载静态内部类。加载类时是线程 安全的。 instance是static final类型，保证了内存中只有这样一个实例存在，并且只能被赋值一次，从而保证了线程安全性.

兼备了并发高效调用和延迟加载的优点！

5、使用枚举实现单例模式

public enum SingletonDemo5 {
    
    //这个枚举元素，自己就是单例对象！
    INSTANCE;
    
    //添加本身须要的操做！
    public void singletonOperation(){
    }
    
}

优势： 实现简单 枚举自己就是单例模式。由JVM从根本上提供保障！避免经过反射和反序列化的漏洞！

缺点： 无延迟加载

常见的五种单例模式在多线程环境下的效率测试

CountDownLatch

同步辅助类，在完成一组正在其余线程中执行的操做以前，它容许一个或多个线程一直等待。

countDown() 当前线程调此方法，则计数减一(建议放在 finally里执行)

await()， 调用此方法会一直阻塞当前线程，直到计时器的值为0

public static void main(String[] args) throws Exception {
        
        long start = System.currentTimeMillis();
        int threadNum = 10;
        final CountDownLatch  countDownLatch = new CountDownLatch(threadNum);
        
        for(int i=0;i<threadNum;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i=0;i<1000000;i++){
                        //Object o = SingletonDemo4.getInstance();
                        Object o = SingletonDemo5.INSTANCE;
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();    //main线程阻塞，直到计数器变为0，才会继续往下执行！
        long end = System.currentTimeMillis();
        System.out.println("总耗时："+(end-start));
    }

总结

主要：

饿汉式（线程安全，调用效率高。 可是，不能延时加载。）

懒汉式（线程安全，调用效率不高。 可是，能够延时加载。）

其余：

双重检测锁式（因为JVM底层内部模型缘由，偶尔会出问题。不建议使用）

静态内部类式(线程安全，调用效率高。 可是，能够延时加载)

枚举式(线程安全，调用效率高，不能延时加载。而且能够自然的防止反射和反序列化漏洞！)

如何选用?

单例对象 占用 资源 少，不须要 延时加载：

枚举式 好于 饿汉式

单例对象 占用 资源 大，须要 延时加载：

静态内部类式 好于 懒汉式