单例模式深探-懒汉式和饿汗式

什么是单例模式

首先说句题外话，单例模式在很多的开源框架和项目都随处可见，所以单例模式的重要不言而喻，在一些稍微大点的公司设计模式肯定是会在面试中会问到的，单例模式的命中率不亚于工厂模式等设计模式（在之后的会陆续补上其它项目中经常用到的设计模式）
进入正题，什么是单例模式，通俗的说就是：在整个对象中，单例类只能有一个实例，单例类必须自己创建自己的唯一实例单例类必须给其它对象提供这一实例

单例模式有哪些（会顺带讲些懒汉式的性能优化）

总得来说单例模式就分这两类，懒汉和饿汉，接下对懒汉和饿汉做介绍

懒汉式

摘自维基百科的解释：懒汉式单例，在第一次调用的时候就实例化自己；懒汉式的优化和问题的症结都是围绕这个第一次调用；第一次调用的言外之意，可以理解为如果我还没调用就创建了实例那么这个就是饿汉式了，讲到这恭喜你已经对单例模式掌握百分之60了
下面是我自己对懒汉式的理解，主要是方便记忆，懒汉式：因为我很懒，所以你要想使用我那么你得调用我一次把我激活了我才给你干活

懒汉式单例模式一般写法

public class Singleton{
    private Singleton(){}
    private static Singleton single = null;
     //静态工厂方法
    public static Singleton getInstance(){
        if(single == null){
            single = new Singelton();
        }
        return single;  
   }  
}

PS:上面的方法是线程不安全的,下面给出线程安全的优化方案

1. 在getInstance方法上加上同步锁

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

2. 双重检查锁定

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

3. 静态内部类

public class Singleton{
    private static class LazyHolder{
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton(){}

    public static final Singleton getInstance(){
        return LazyHolder.INSTANCE;
    }
}
//ps:这种比上面的1,2都好一些，即实现了线程安全，又避免了同步锁带来的性能影响

看到上面3的解决方法的话，可能有一些疑问，不知所云，现在我附上一些解释。
这个解决方案的名字是Lazy initialization holder class。这个模式综合运用了java的类级内部类和多线程缺省同步锁的知识。
先来补充一下基础知识，以下内容来源自清华大学出版社的《研磨设计模式》。
先简单看看类级内部类相关的知识
      *什么是类级内部类？
      简单点说，类级内部类指的是，有static修饰的成员式内部类。如果没有static修饰的成员式内部类叫对象级内部类。
*类级内部类相当于其外部类的static成分，他的对象与外部类对象间不存在依赖关系，因此可直接创建，而对象级内部类的实例，是绑定在外部对象实例中的。
*类级内部类中，可以定义静态的方法。在静态的方法中只能够引用外部类的中的静态成员方法或者成员变量。
*类级内部类相当于其外部类的成员，只有在第一次被使用的时候才会被装载。
再来看看多线程缺省同步锁的知识。
大家都知道，在多线程开发中，为了解决兵法问题，主要通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含的执行了同步，这些情况下就不用自己再来进行同步控制了，这些情况包括：
       *由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时
       *访问 final 字段时
       *再创建线程之前创建对象时
       *线程可以看见他将要处理的对象时
由此想要很简单的实现线程安全，可以采用静态初始化器的方式，他可以由JVM来保证线程的安全性。比如第一节的饿汉式实现方式。但是这样一来，会浪费一定的空间，因为这种实现方式，会在类装载的时候就初始化对象，不管你需不需要。
如果现在有一种方法能够让类装载的时候不会初始化对象，不就解决问题了？一种客卿的方式就是采用类级内部类，在这个累计内部类里面去创建对象实例。这样一来，只要不适用这个类级内部类，那就不会创建对象实例。从而同时实现延迟加载和线程安全。

饿汉式

在类初始化的回收，已经自行实例化；它天生就是线程安全的

public class Singleton{
    private Singleton(){}

    private static final Singleton single = new Singleton();

    public static Single getInstance(){
        reutrn single;
    }
}
//ps:饿汉式在类创建的同时，已经创建好对象，以后不再改变，所以天生就是线程安全的

懒汉式与饿汉式的区别

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例对象的实例化已经存在；
而懒汉式比较懒，只有当调用getInstance的时候，才会去初始化这个单例

• 线程安全
  饿汉式天生就是线程安全的，可以直接用于多线程；
  懒汉式本身是非线程安全的，为了实现线程安全有上面的1、2、3三种方式，这三种方式在资源和性能上有写区别

• 资源加载和性能
  饿汉式在类创建的同时就实例化一个静态对象，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，
  在第一次调用时速度也会更快，因为资源已经初始化完成。而懒汉式顾名思义，会延迟加载，在第一次使用该单例的会后才会实例化对象出来
  第一次调用时要做初始化，如果要做的工作比较多，性能上会有延迟，之后就和饿汉式一样

针对懒汉式1、2、3三种实现的区别

• 第1种：在方法上调用了同步锁，虽让线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的
• 第2种：在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会去同步，这样既实现了线程安全，同时避免了每次都同步的性能损耗
• 第3种：利用classLoader机制（类加载机制）来保证初始化instance时既能只有一个线程，所以也是线程安全的，同时没有性能损耗，推荐这种