你写的单例模式不一定正确

单例模式是设计模式中最容易理解、最容易上手的设计模式，同时也是最容易出错的设计模式。它的实现写法有多种，但是并不都是正确的写法。
1.饿汉模式
饿汉，即迫切的、立马的，所以饿汉模式又称作立即加载，下面代码实现是它最普遍的写法。

public class SingletonObject {
    private static final SingletonObject singletonObject = new SingletonObject();

    private SingletonObject() {

    }

    public static SingletonObject getInstance() {
        return singletonObject;
    }
}

这种写法实现的单例对象会在类加载时创建，线程安全的。它的缺点很明显了，不能依赖参数或配置文件创建对象。
2.懒汉模式
懒汉，即慵懒的、不着急的，所以懒汉模式又称作延迟加载，下面代码即是它的实现。

public class SingletonObject {
    private static SingletonObject singletonObject;

    private SingletonObject() {

    }

    public static SingletonObject getInstance() {
        if (singletonObject == null) {
            singletonObject = new SingletonObject();
        }
        return singletonObject;
    }
}

它可以根据参数或配置创建对象，这种写法很常见，但却是一种错误的写法，因为getInstance方法没有做同步控制，在多线程并发的情况下会出现线程不安全的情况，即创建多个实例对象。
3.懒汉模式的同步版
为了解决懒汉模式的非线程安全问题，实现了下面的这种写法。

public class SingletonObject {
    private static SingletonObject singletonObject;

    private SingletonObject() {

    }

    synchronized public static SingletonObject getInstance() {
        if (singletonObject == null) {
            singletonObject = new SingletonObject();
        }
        return singletonObject;
    }
}

这种实现方式虽然解决了非线程安全问题，是线程安全的，但是效率较低，因为在多线程并发时，getInstance方法需要同步，同一时间只有一个线程可以访问执行，排队执行。
4.懒汉模式的双检查版本
为了解决上面出现的效率低的问题，对代码进行了修改。

public class SingletonObject {
    private static SingletonObject singletonObject;

    private SingletonObject() {

    }

    public static SingletonObject getInstance() {
        if (singletonObject == null) {
            synchronized (SingletonObject.class) {
                if (singletonObject == null) {
                    singletonObject = new SingletonObject();
                }
            }
        }
        return singletonObject;
    }
}

双检查，即进行了两次singletonObject == null的判断，相对于上面的写法，效率上提升了一些。但是，它也是有问题的。问题的原因在于singletonObject = new SingletonObject()，这个不是原子操作，它的执行分以下先后三步：
一.给新创建的对象分配内存；
二.调用构造方法初始化成员变量；
三.将singletonObject指向新对象的内存空间。
上面的三步，执行到第三步时，singletonObject已经不是null了。然而JVM即时编译器存在指令重排序的优化，所以上面三步的执行顺序可能是一二三，也可能是一三二，当按后者顺序执行到三时，另一个线程执行到了if里面的非null判断，此时singletonObject已经不为null了，然而成员变量的值没有初始化，另一个线程直接拿着这个没有初始化完全的对象进行操作时，定会出错。
5.懒汉模式双检查版本的加强版
为了解决上面未初始化完全的问题，使用volatile修改代码。

public class SingletonObject {
    private volatile static SingletonObject singletonObject;

    private SingletonObject() {

    }

    public static SingletonObject getInstance() {
        if (singletonObject == null) {
            synchronized (SingletonObject.class) {
                if (singletonObject == null) {
                    singletonObject = new SingletonObject();
                }
            }
        }
        return singletonObject;
    }
}

你可能认为使用volatile是为了实现多线程间的可见性，这里不是这个目的。这里的volatile是为了禁止指令的重排序，能保证happens-before relationship，所有的写都将先行发生于读。需要注意的是，在JDK 5之前的版本中使用volatile并不能完全阻止指令的重排序，原因是Java内存模型存在缺陷导致的。
6.静态内部类的实现
静态内部类的方式是推荐的一种实现写法。

public class SingletonObject implements Serializable {
    private SingletonObject() {

    }

    private static class SingletonObjectHolder {
        private static SingletonObject singletonObject = new SingletonObject();
    }

    public static SingletonObject getInstance() {
        return SingletonObjectHolder.singletonObject;
    }

    protected Object readResolve() {
        return SingletonObjectHolder.singletonObject;
    }
}

因为JVM本身的机制保证了这种写法是线程安全的，延迟加载，没有性能方面的缺陷。
7.静态代码块的实现

public class SingletonObject implements Serializable {
    private static SingletonObject singletonObject;

    private SingletonObject() {

    }

    static {
        singletonObject = new SingletonObject();
    }

    public static SingletonObject getInstance() {
        return singletonObject;
    }
}

因为静态的代码块只能被执行一次，所以，这种写法是线程安全的。
8.枚举的实现
使用枚举实现单例，这种方式也是线程安全的，但是使用的比较少，读者可自行实现。

总结：