JAVA设计模式之单例模式（面试必考）

单例模式

java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。
　　单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

懒汉式：
在第一次调用的时候就实例化自己

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

因为是懒汉式，所以就并没有考虑线程安全问题，所以它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式

1. 在getInstance方法上加同步关键字

场景：在并发环境下，多个一起进入到这个getInstance里面，因为还没有实例化懒汉式单例类，所以自然也没有single，single都为null，然后并发执行这个函数，就都会进入到if条件中去，然后去创建很多个Singleton实例化对象，这样就破坏了单例模式想要的结果
解决方法：我们可以在这个getInstance方法上加锁，当有一个执行这个函数的时候，其他想要调用这个函数的进入阻塞状态，然后等这个函数执行完了之后，就创建好了实例化，single便不是null了，然后在释放锁，之后调用这个getInstance方法的时候，就不会进入if条件中了，单例模式就此实现了

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

2. 双重检查锁定
   解决方法：
   在我们进入if条件的时候，也就是没有这个singleton，需要创建一个Singleton实例化对象的时候加一把锁，如果并发环境下，有人又调用了这个函数，这个时候是可以进入第一个if里面的，但是进入条件中，锁被拿走了，进入了阻塞状态，然后当重新拿到锁了之后，却无法进入第二个if条件了，直接return得到我们的singleton单例对象了，如下图所示

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

拓展：双重检查锁定（DCL：Double Check Lock）的单例需不需要再加上volatile关键字来确保线程安全？
答案是需要的。

创建对象三部曲：
1.开辟内存空间 调用
2.调用给成员变量赋值
3.引用赋值

半初始化，是指可能进行重排序后，第三步和第二步换了一下，导致引用赋值后Singleton 处于成员变量还是默认值的状态
而此时恰好处于多线程状态，下一个线程是不会进入到一个if中的，而是会直接返回那个半初始化的对象，如果恰恰在这个时候，该线程还是没有被第一个线程抢夺回CPU的控制权，而拿到这个本初始化的对象中的成员变量去进行一些操作的时候，就是出现问题。

可能由于CPU的对于代码执行顺序的重排序，然后导致创建单例的时候处于半初始化状态，然后指向的是没进行init方法的使用默认成员变量的内存空间，从而导致该单例在使用中出现问题

3. 静态内部类
   这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

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

饿汉式

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

饿汉式和懒汉式区别
从名字上来看，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当用户调用getInstance的时候，才回去初始化这个单例。

1、线程安全：
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

懒汉式本身是非线程安全的，但是为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

2、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。

第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会极大的影响性能，毕竟99%的情况下是不需要同步的，

第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗，这种相较于第一种性能提高了很多

第3种，利用了classloader（类加载）的机制来保证在类变成class字节码文件的之后就已经执行了静态代码块里面的内容了，这样也能保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以性能最高的也就是这一种了。