单例模式的写法

1.饿汉式（普通）

线程安全
适用于构造函数初始化内容少，且保证能用到的场景。
否则会造成资源浪费

public class SingletonTest1 {

    private SingletonTest1(){}

    private static SingletonTest1 instance=new SingletonTest1();

    public static SingletonTest1 getInstance(){
        return instance;
    }
}

2.饿汉式（静态代码快）

线程安全和性能同1。

public class SingletonTest2 {

    private SingletonTest2() {
    }

    private static SingletonTest2 instance = null;

    static {
        instance = new SingletonTest2();
    }

    public static SingletonTest2 getInstance() {
        return instance;
    }
}

3.懒汉式–双重同步锁

线程安全，对象在第一次使用时创建

---

注意：
volatile不能少,否则不能保证线程安全

---

初始化一个对象的过程：
1.memory=allocate() 分配对象内存空间
2.ctoInstance() 初始化对象
3.instance=memory 设置instace指向刚分配的内存空间

因为JVM可能出现指令重拍，2和3不存在依赖关系，所以顺序不一定。
当不加voltile时，A线程执行1-3-2的顺序，执行到代码中A-3的位置。
此时instance已创建未初始化。
B线程进入判断，instance不为空，则返回一个未初始化的对象。
存在线程不安全，所以需要volatile来修饰，禁止指令重排序。

---

public class SingletonTest3 {

    private SingletonTest3() {
    }

    private static volatile SingletonTest3 instance = null;

    public static SingletonTest3 getInstance() {
        if(instance==null){//B
            synchronized (SingletonTest3.instance){
                if (instance==null){
                    instance=new SingletonTest3();//A-3
                }
            }
        }
        return instance;
    }
}

4.枚举式

利用jvm特性，保证线程安全，且在使用时才创建。推荐使用

public class SingletonTest4 {

    private SingletonTest4() {
    }

    public SingletonTest4 getInstance() {
        return Singleton.INSTANCE.getInstance();
    }

    private enum Singleton {
        INSTANCE;

        private SingletonTest4 instance;

        //JVM保证构造函数只被调用一次
        Singleton() {
            instance = new SingletonTest4();
        }

        public SingletonTest4 getInstance() {
            return instance;
        }
    }
}