JAVA设计模式之单例模式详解

单例模式有两种实现方式，一种是饿汉式，一种是懒汉式。

饿汉式：类加载到内存后，就实例化一个单例，JVM保证线程安全，简单实用，推荐使用！唯一缺点，不管用到与否，类装载时就完成实例化，也就是Class.forName("")加载到内存就会实例化。（不过话又说回来，你如果不用它，你要装载它干啥）。

懒汉式：类加载到内容后，不会实例化一个单例，而是在需要时才实例化，但是实现这个方式需要考虑到一些问题，下面我们来分析。

 

1、饿汉式

一、直接初始化

public class MgrTest01 {
    private static final MgrTest01 INSTANCE = new MgrTest01();

    private MgrTest01() {};

    public static MgrTest01 getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        MgrTest01 mgrTest011 = MgrTest01.getInstance();
        MgrTest01 mgrTest012 = MgrTest01.getInstance();

        System.out.println(mgrTest011 == mgrTest012);
    }
}

执行结果：true

二、使用静态语句初始化（本质上和直接初始化没有什么区别）

public class MgrTest02 {
    private static final MgrTest02 INSTANCE;

    static {
        INSTANCE = new MgrTest02();
    }

    private MgrTest02() {};

    public static MgrTest02 getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        MgrTest02 mgrTest011 = MgrTest02.getInstance();
        MgrTest02 mgrTest012 = MgrTest02.getInstance();

        System.out.println(mgrTest011 == mgrTest012);
    }
}

结果：true

2、懒汉式

一、按需初始化

public class MgrTest03 {
    private static MgrTest03 INSTANCE;

    private MgrTest03() {};

    public static MgrTest03 getInstance()  {
        if(null == INSTANCE){
            try {
                Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new MgrTest03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest03.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest03.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象可能会不同（虽然达到了按需初始化的目的，但是却带来了线程不安全的问题）

问题原因：因为在对象还没有创建之前。多个线程同时调用getInstance方法获取实例的时候，可能存在第一个线程进入了if语句，但是还没有来的及执行实例化对象，后面线程也进入了if语句。等到第一个线程实例化之后，虽然这个时候再有线程调用getInstance，不会再进入if语句直接拿对象，但是已经进入if语句的线程又创建了新的对象。（注意：我们可以看到前五次的对象可能不是同一个，但是后五次肯定是同一个了(中间加入延迟是模拟在对象创建之后再调用getInstance的场景)，所以这个问题是在对象还没有创建之前，然后有多个线程同时调用getInstance方法可能出现的问题）

二、可以通过synchronized来解决上个问题

public class MgrTest04 {
    private static MgrTest04 INSTANCE;

    private MgrTest04() {};

    public static synchronized MgrTest04 getInstance()  {
        if(null == INSTANCE){
            try {
                Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new MgrTest04();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest04.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest04.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象都是同一个（可以实现懒加载，并且不会有线程安全的问题，但是效率下降）

但是又引发了另一个问题，每次调用getInstance方法的时候都要加锁，因为调用加了synchronized的方法每次都要去判断有没有申请到这把锁，执行效率就降低了。本来我们只是解决在INSTANCE还没有实例化的时候线程安全问题，而INSTANCE初始化之后调用getInstance方法是不会有线程安全问题的，所以我们只需要在INSTANCE为空的时候才需要加锁获取，已经不为空了就没有必要还加锁获取。

 三、通过减小同步代码快的方式提高效率，但是不可行（需要注意）

public class MgrTest05 {
    private static MgrTest05 INSTANCE;

    private MgrTest05() {};

    public static MgrTest05 getInstance()  {
        if(null == INSTANCE){
            synchronized (MgrTest05.class){
                try {
                    Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new MgrTest05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest05.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest05.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象可能会不同（虽然减少了同步代码块，但是出现了线程安全问题）

问题原因：和上面讲的懒加载第一种方式问题类似，虽然把实例化INSTANCE对象的代码同步了，但是还是有可能存在第一个线程进入了if语句，然后进入了同步代码块上锁了，但是还没有来的及执行实例化对象，后面线程也进入了if语句，只是被锁在实例化对象语句外面，等到第一个进入同步代码的线程出来后，被锁在外面的线程还是可以进入，然后实例化了新的对象，就出现了上面类似的线程安全问题。

四、通过双重检查来解决上一个问题

public class MgrTest06 {
    //做JIT优化的时候会指令重排 加上volatile关键之阻止编译时和运行时的指令重排
    private static volatile MgrTest06 INSTANCE;

    private MgrTest06() {};

    public static MgrTest06 getInstance()  {
        if(null == INSTANCE){
            synchronized (MgrTest06.class){
                //双重检查
                if(null == INSTANCE){
                    try {
                        Thread.sleep(10);//延迟10毫秒、让问题出现的可能性增大
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new MgrTest06();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest06.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest06.getInstance())).start();
        }
    }
}

执行结果：获取的实例对象都是同一个（可以实现懒加载，并且不会有线程安全的问题，同时也解决了效率问题）

这样实现了只在INSTANCE为空的时候才需要加锁获取实例，已经不为空了再调用getInstance方法就判断不为空，然后直接获取。

五、静态内部类单例

public class MgrTest07 {
    private MgrTest07() {};

    private static class MgrTest07Holder{
        private static final MgrTest07 INSTANCE = new MgrTest07();
    }

    public static MgrTest07 getInstance(){
        return MgrTest07Holder.INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest07.getInstance())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest07.getInstance())).start();
        }
    }
}

执行结果：（JVM保证单例，虚拟机加载类的时候只加载一次，所以INSTANCE也只会加载一次，同时实现了懒加载，因为加载外部类时不会加载内部类）

六、枚举单例（不仅可以解决线程同步，还可以防止反序列化）

public enum MgrTest08 {

    INSTANCE;

    public static void main(String[] args){
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest08.INSTANCE.hashCode())).start();
        }
        try {
            Thread.sleep(3000);//延迟3秒、模拟单例INSTANCE已经有值之后再调用getInstance
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<5;i++){
            new Thread(() -> System.out.println(MgrTest08.INSTANCE.hashCode())).start();
        }
    }
}

执行结果：

总结：一般使用直接初始化单例的和静态内部类单例的方式就可以了，不过使用枚举单例的方式更好，因为只有枚举单例，不仅可以解决线程安全问题，还可以防止反序列化，主要看实际开发中需不需要考虑到这些问题，来选择哪种方式实现单例就可以了。

---

序列化的问题：

为什么在做单例的时候要防止这一点？

因为java的反射是通过一个class文件，然后把整个class加载到内存，再把它创建一个实例出来，而除了枚举方式，其它的都可以找到class文件通过反序列化的方式（反射）再创建一个实例出来，如果想让它不能被反序列化需要设置一些变量，过程比较复杂。

枚举单例为什么可以防止反序列化？

因为枚举类没有构造方法（java规定没有构造方法），就算拿到class文件也没有办法实例化一个对象出来，它反序列化只是一个INSTANCE值（当前案例），然后根据这个值来找对象的话，找到的是和单例创建的同一个对象。