JAVA单例模式实现详解

单例模式的特点

• 类的内部包括待返回的类的实例，为private static类型
• 类的构造函数为私有构造函数，以防止在其他类中实例化，private的作用是防止在其他类中用构造函数创建该类的实例
• 提供一个获取实例的静态方法

单例模式1:饱汉模式+考虑了线程安全(双重检查锁)

public class Singleton1 {
    private static volatile Singleton1 instance = null;//volatile不具有原子性

    //构造方法：如果构造方法是 public，那么任何类都可以 new 我的对象，不能保证单例，
    // 所以单例模式构造方法一定是 private的
    private Singleton1() {

    }
    public static Singleton1 getInstance() {

        if (instance == null) {//只有instance == null这种情况下需要进行加锁synchronized
            synchronized (Singleton1.class) {//静态方法中上锁用的是类名.class
                if (instance == null)
                    instance = new Singleton1();
            }
        }
        return instance;

    }
}

为什么需要第一重instance == null呢？

这里就涉及一个性能问题了，因为对于单例模式的话，newSingleTon（）只需要执行一次就 OK 了，

而如果没有第一重instance == null 的话，每一次有线程进入getInstance（）时，均会执行锁定操作来实现线程同步，

这是非常耗费性能的，而如果我加上第一重instance == null 的话，

那么就只有在第一次，也就是instance ==null 成立时的情况下执行一次锁定以实现线程同步，

而以后的话，便只要直接返回Singleton实例就 OK 了而根本无需再进入 lock语句块了，这样就可以解决由线程同步带来的性能问题了。

为什么需要第二重instance == null呢？

考虑这样一种情况，就是有两个线程同时到达，即同时调用getInstance() 方法，

此时由于instance == null ，所以很明显，两个线程都可以通过第一重的 instance == null ，

进入第一重 if语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 instance == null ，

而另外的一个线程则会在lock 语句的外面等待。

而当第一个线程执行完new SingleTon（）语句后，便会退出锁定区域，此时，第二个线程便可以进入lock 语句块，

此时，如果没有第二重instance == null 的话，那么第二个线程还是可以调用 new SingleTon（）语句，

这样第二个线程也会创建一个SingleTon实例，这样也还是违背了单例模式的初衷的，

所以这里必须要使用双重检查锁定。

为什么要用volatile?

主要是为了保证有序性(禁止指令重排序)

java中new一个对象是由多个步骤组成的，而这些步骤可能会被编译器重排序，从而导致其他线程获取到一个没有被完全初始化的对象，而 volatile 就
是告诉编译器不要重排序。

这里volatile的作用仅仅是阻止指令重排序, 不涉及可见性问题, 可见性已经由synchronized来保证了(synchronized也有阻止重排序的功能, 但是其由monitor来实现, monitorenter和monitorexit之间的指令仍可能被重排序).

单例模式2:饿汉模式

public class Singleton2 {
    private static final Singleton2 singleton = new Singleton2();
    private Singleton2() {
    }
    public static Singleton2 getInstance() {
        return singleton;
    }
}

• 饿汉的好处是天生的线程安全（得益于类加载机制），写起来超级简单，使用时没有延迟；
• 坏处是有可能造成资源浪费（如果类加载后就一直不使用单例的话）

单例模式3:Holder模式（增加了一个静态内部类）

public class Singleton3 {
    // 加载一个类时，其内部类不会同时被加载。
    // 一个内部类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。
    private static class SingletonHolder {
        private static final Singleton3 singleton = new Singleton3();
        private SingletonHolder() {
        }
    }
    private Singleton3() {
    }
    public static Singleton3 getInstance() {
        return SingletonHolder.singleton;
    }
}

• 相对于饿汉模式，Holder模式仅增加了一个静态内部类的成本，
• 与饱汉的线程安全写法的效果相当（略优），都是比较受欢迎的实现方式。同样建议考虑。
• 该实现方式比较简单，而且既实现了由前述事实所保证的惰性初始化（Lazy-Initialazation），又由JVM保证了多线程并发访问的正确性。

参考链接:

• 为什么要双重检查锁
  https://blog.csdn.net/u010365819/article/details/80240255

• 为什么要用volatile?
  https://www.zhihu.com/question/56606703