单例模式_边吃边说！

单例模式

单例模式（Singleton Pattern）是Java中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它保证一个类仅有一个实例，并提供一个访问它的全局访问点，可以防止一个全局使用的类频繁地创建与销毁。所以当我们想要控制实例数目，节约系统资源的时候就可以使用单例模式。

注意事项：

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例（构造器私有）。
3. 单例类必须给所有其他对象提供这一实例。

饿汉式

饿汉式顾名思义就是很饥饿，不管执行啥任务，都得先吃再说，所以当类加载时就初始化了。它基于classloader机制避免了多线程的同步问题，所以是线程安全的。不过很容易产生垃圾对象，造成空间浪费的问题。

//饿汉式单例
public class Hungry {

    //假如我们里面有这些代码，是不是就很浪费空间呢
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    
    //刚进饭馆就要菜，现成的
    private static Hungry instance = new Hungry();
    private Hungry(){}
    public static Hungry getInstance(){
        return instance;
    }
}

懒汉式

懒汉式-单线程版本

懒汉式就没有饿汉式那么饿了，只要它想要吃饭了再做菜就可以。那么先来个私人饭店版本（单线程版）。

//懒汉式单例,单线程版本
public class Lazy {
    //先做好准备，啥时候想吃再做。
    private static Lazy instance = null;
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    public static Lazy getInstance(){
        //饿了，发现没菜，没事不着急，慢慢做。
        if(instance == null){
            instance = new Lazy();
        }
        //做好了，上菜。
        return instance;
    }

    //多线程下是不安全的
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

运行结果：

分析线程不安全原因：

懒汉式-多线程-低性能版

单线程版本既然是在getInstance()方法里面出现了线程不安全，那么可以怎么解决？直接给getInstance()方法加上锁synchronized就好了，但是加锁会影响效率，懒汉想吃饭了想进饭店进不去，被前面的霸道客人直接锁住了，不管有没有菜都得等着。

//懒汉式单例,多线程版本
public class Lazy {
    //先做好准备，啥时候想吃再做。
    private static Lazy instance = null;
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    //饿了，但是发现饭馆里有人，而且只能一个人进去，只能等待
    public static synchronized Lazy getInstance(){
        if(instance == null){
            instance = new Lazy();
        }
        return instance;
    }

    //多线程下是安全的
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

运行结果：

懒汉式-双重校验锁（重点）

懒汉式-双重校验锁（DCL，即double-checked locking），刚才低性能版是把饭店直接锁住了，所以懒汉也不知道厨房有没有做好菜，那么双重校验锁就是让客人们都可以进入饭店，询问服务员有没有做好菜（ if(instance == null) )，服务员如果说做好了(false)，直接上菜（return），如果说没有做好(true)，前面有人(厨房上锁)，则等待，前面没人，则进入厨房，上锁，做菜(初始化)。

//懒汉式-双重校验锁
public class Lazy1 {
    private volatile static Lazy1 instance = null;
    private Lazy1(){}
    private static Lazy1 getInstance(){
        if(instance == null){
            synchronized (Lazy1.class){
                if(instance == null){
                    instance = new Lazy1();
                }
            }
        }
        return instance;
    }
}

分析为什么使用volatile（重点）

登记式/静态内部类

使用静态内部类方式能达到双重校验锁一样的功效，并且实现起来更简单。对静态域使用延迟初始化，应使用这种方式而不是双重校验锁方式。

//登记式、静态内部类
public class Holder {
    private Holder(){}

    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

反射破坏单例

有人上锁就有人撬，反射也是可以创建对象的，并可以消除权限检验，那么接下来就演示一下用反射破坏双重校验锁。

import java.lang.reflect.Constructor;

//反射破解双重校验锁
public class Lazy2 {
    private Lazy2(){}
    private volatile static Lazy2 instance = null;

    public static Lazy2 getInstance(){
        if(instance == null){
            synchronized (Lazy2.class){
                if(instance == null){
                    instance = new Lazy2();
                }
            }
        }
        return instance;
    }
    //反射破解
    public static void main(String[] args) throws Exception {
        //用单例模式创建对象
        Lazy2 instance = Lazy2.getInstance();
        //通过反射获取构造器
        Constructor<Lazy2> declaredConstructor = Lazy2.class.getDeclaredConstructor(null);
        //消除构造器权限检验
        declaredConstructor.setAccessible(true);
        //构造对象
        Lazy2 instance1 = declaredConstructor.newInstance();

        //通过两个对象的hashCode值来对比是否为同一对象
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());
    }
}

运行结果：

枚举式

在我们用反射创建对象调用newInstance()方法时，打开其源代码观察发现，枚举是不可以被破坏的。

枚举式不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

//枚举式，enum本身也是一个Class类
public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}