单例模式的演进

1

public class Singleton {
    //此处为饿汉式，static让代码加载的时候就已经创建这个对象了，并且final修饰，多线程安全，不会多次创建新的对象，代码运行时别的线程也不会更改。
    private static final Singleton instance = new Singleton();
    private Singleton(){};

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

2

public class Singleton01 {
    //懒汉式，instance需要的时候才会创建，节省空间，实际开发中没有必要。
    private static Singleton01 instance = null;

    private Singleton01() {
    }

    //多线程情况下会创建多个对象。
    public static Singleton01 getInstance() {
        if (instance == null) {
            instance = new Singleton01();
        }
        return instance;
    }
}

3

public class Singleton02 {
    private static Singleton02 instance = null;

    private Singleton02() {
    }

    //没有线程安全问题，但是synchronized锁的代码太多，影响效率。
    public static synchronized Singleton02 getInstance() {
        if (instance == null) {
            instance = new Singleton02();
        }
        return instance;
    }
}

4

public class Singleton03 {
    private static Singleton03 instance = null;

    private Singleton03() {
    }

    public static Singleton03 getInstance() {
        //不需要加锁的业务代码，这样效率高一些
        if (instance == null) {
            //多线程情况下，第一个线程进入此处之后创建对象释放锁，第二个线程等待此处获得锁继续运行之后又创建了一个新的对象。
            synchronized (Singleton03.class){
                instance = new Singleton03();
            }
        }
        return instance;
    }
}

5

public class Singleton04 {
    private static Singleton04 instance = null;

    private Singleton04() {
    }

    public static Singleton04 getInstance() {
        //不需要加锁的业务代码，这样效率高一些
        if (instance == null) {
            //多线程情况下，第一个线程进入此处之后创建对象释放锁，第二个线程等待此处获得锁继续运行之后又创建了一个新的对象。
            synchronized (Singleton04.class) {
                //所以此处再加一层instance == null的判断。第二个线程就不会新创建对象了。
                //DCL double check lock
                if (instance == null) {
                    instance = new Singleton04();
                }
            }
        }
        return instance;
    }
}

6

public class Singleton05 {
    //volatile防止指令重排序
    private static volatile Singleton05 instance = null;

    private Singleton05() {
    }

    public static Singleton05 getInstance() {
        //不需要加锁的业务代码，这样效率高一些
        if (instance == null) {
            //多线程情况下，第一个线程进入此处之后创建对象释放锁，第二个线程等待此处获得锁继续运行之后又创建了一个新的对象。
            synchronized (Singleton05.class) {
                //所以此处再加一层instance == null的判断。第二个线程就不会新创建对象了。
                //DCL double check lock
                if (instance == null) {
                    instance = new Singleton05();
                }
            }
        }
        return instance;
    }
}

volatile防止指令重排
对象创建 1、初始化默认值0；2、构造方法将对象内部变量初始化；3、将对象指给对应的变量
有很小的概率会指令第2步和第三步重排。导致代码中instance不是null, 但实际对象还没有构造函数完全初始化。