单例模式

原因

        加粗样式单例是无状态的，目的是节约内存空间，实现类的重用。

方式

1. 懒汉方式（有缺陷）

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}
    public static Singleton getSingleton() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }

缺陷：
        当并发访问的时候，第一个调用getInstance方法的线程A，在判断完singleton是null的时候，线程A就进入了if块准备创造实例，但是同时另外一个线程B在线程A还未创造出实例之前，也进行了singleton是否为null的判断，这时singleton依然为null，所以线程B也会进入if块去创造实例，这时问题就出来了，有两个线程都进入了if块去创造实例，结果就造成单例模式并非单例。

---

2.同步方式（有缺陷）

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

缺陷：
        虽然保证了同步，但是增加的等待时间。

---

3. 双重检验锁（有缺陷，通过增加volatile关键字避免重排序）

class Singleton4 {
    private (volatile) static Singleton4 singleton4;
    private Singleton4() {}
    public static Singleton4 getInstance(){
        if(singleton4 == null){
            synchronized(Singleton4.class){
                if(singleton4 == null){
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }
}

缺陷：
        假设我们去掉同步块中的是否为null的判断，有这样一种情况，假设A线程和B线程都在同步块外面判断了singleton4为null，结果A线程首先获得了线程锁，进入了同步块，然后A线程会创造一个实例，此时singleton4已经被赋予了实例，A线程退出同步块，准备返回第一个创造的实例，与此同时，B线程获得线程锁，也进入同步块，此时A线程其实已经创造好了实例，B线程正常情况应该直接返回的，但是因为同步块里没有判断是否为null，直接就是一条创建实例的语句，所以B线程也会创造一个实例返回，此时就造成创造了多个实例的情况。
如果我们深入到JVM中去探索上面这段代码，它就有可能（注意，只是有可能）是有问题的。因为虚拟机在执行创建实例的这一步操作的时候，其实是分了好几步去进行的，也就是说创建一个新的对象并非是原子性操作。在有些JVM中上述做法是没有问题的，但是有些情况下是会造成莫名的错误。
        首先要明白在JVM创建新的对象时，主要要经过三步：
        - 分配内存
        - 初始化构造器
        - 将对象指向分配的内存的地址

        这种顺序在上述双重加锁的方式是没有问题的，因为这种情况下JVM是完成了整个对象的构造才将内存的地址交给了对象。但是如果2和3步骤是相反的（2和3可能是相反的是因为JVM会针对字节码进行调优，而其中的一项调优便是调整指令的执行顺序），就会出现问题了。 因为这时将会先将内存地址赋给对象，针对上述的双重加锁，就是说先将分配好的内存地址指给singleton4，然后再进行初始化构造器，这时候后面的线程去请求getInstance方法时，会认为singleton4对象已经实例化了，直接返回一个引用。如果在初始化构造器之前，这个线程使用了singleton4，就会产生莫名的错误。

---

4. 静态代码块方式（有缺陷）

class Singleton1 {
    private static Singleton1 singleton1;
    private Singleton1() {}
    static {
        singleton1 = new Singleton1();
    }
    public static Singleton1 getInstance() {
        return singleton1;
    }
}

缺陷：
        加载class的时候创建实例，如果不使用则会造成内存浪费，但能保证单例。

---

5.饿汉方式（静态属性方式）（有缺陷）

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

缺陷：
        调用任意方法的时候创建实例，如果不使用则会造成内存浪费，但能保证单例。

---

6. 静态内部类方式（标准单例）

class Singleton5{
    private Singleton5(){}
    public static Singleton5 getInstance(){
        return Singleton.singleton;
    }
    private static class Singleton{
        private static Singleton5 singleton = new Singleton5();
    }
}

---

7. 枚举方式（最安全、便捷）

class Resource{
}

enum SomeThing {
    INSTANCE;
    private Resource instance;
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
    
    public static void main(String[] args) {
        SomeThing.INSTANCE.getInstance();
    }
}