Java中单例模式的实现

单例模式作为23种设计模式中最常用的一种，也是面试中的常客，但是很少有人能把每种实现方式的不同讲清楚的，今天我们就来探讨下它。

1、单例模式的作用

单例模式主要用于解决多次调用的地方都是用的同一个实例，避免一个应用中存在多个该对象的实例，常见的实现手段就是不允许外部创建对象，将构造方法私有化，自己提供静态方法将对象的实例暴露出去。

2、常见的几种单例模式的实现

2.1 懒汉、饿汉、变种饿汉(静态代码块实现)模式

这两种模式在实现上都有一定的缺陷，懒汉模式要实现多线程安全就需要对getInstance()方法上加上synchronize 关键字，效率很低，饿汉模式虽然一开始就创建了实例，但是在类加载的时候就创建了对象，不能实现懒加载。

懒汉:

/**
 * Created by jiangcheng on 2017/9/28.
 */
public class Singleton {

    private static Singleton sInstance;
    // 私有构造方法
    private Singleton() {}

    public static synchronized Singleton getInstance () {
        if (sInstance == null) {
            sInstance = new Singleton();
        }
        return sInstance;
    }
}

2.2 双重检测

由于懒汉模式是对方法进行加锁的，所以当多个线程同时访问该方法时，效率很低，synchronized修饰的同步方法比一般方法要慢很多。

双重检测:

public class Singleton {

    private static Singleton sInstance;

    private Singleton() {}

    public static Singleton getInstance () {
        if (sInstance == null) {   // 1
            synchronized (Singleton.class) {
                if (sInstance == null) {  // 2
                    sInstance = new Singleton();
                }
            }
        }

        return sInstance;
    }
}

我们来分析下，双重检测的原理，可以看到上面代码1处在同步代码块外多了一层instance为空的判断。由于单例对象只需要创建一次，如果后面再次调用getInstance()只需要直接返回单例对象。因此，大部分情况下，调用getInstance()都不会执行到同步代码块，从而提高了程序性能。不过还需要考虑一种情况，假如两个线程A、B，A执行了if (instance == null)语句，它会认为单例对象没有创建，此时线程切到B也执行了同样的语句，B也认为单例对象没有创建，然后两个线程依次执行同步代码块，并分别创建了一个单例对象。为了解决这个问题，还需要在同步代码块中增加if (instance == null)语句，也就是上面看到的代码2。

• 这种实现就真的完美么？

由于java平台的指定优化重排后的无序性，会导致初始化Singleton和将对象地址赋给instance字段的顺序是不确定的。在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错，双重检测就会失效。

不过JDK 1.5后 Java中提供了关键字 volatile。 volatile的一个语义是禁止指令重排序优化，他定义的变量在多线程操作中，是对所有线程可见的，也就保证了instance变量被赋值的时候对象已经是初始化过的，从而避免了上面说到的问题。

private static volatile Singleton sInstance;    // volatile 关键字的使用

2.3 静态内部类(推荐)

public class Singleton {
    private Singleton() {}
    
    private static class SingletonHolder {
        private static Singleton sInstance = new Singleton();
    }

    public static Singleton getInstance () {
        return SingletonHolder.sInstance;
    }
}

这种方式利用了Java在类加载的时候只允许一个线程加载，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。这种方式比较容易看的懂，也很简洁，所以推荐改种实现方式。

2.4 枚举

public enum Singleton {
    instance;
    public void whateverMethod() {
    }
}

由于前面几种都有两个共同的缺点:

1. 需要额外的工作来实现序列化，否则每次反序列化一个序列化的对象时都会创建一个新的实例。
2. 可以使用反射强行调用私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）。

而枚举类很好的解决了这两个问题，使用枚举除了线程安全和防止反射调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，《Effective Java》作者推荐使用的方法。不过，在实际工作中，很少看见有人这么写。

枚举在Java中是很特殊的存在，可以参考Java枚举enum及其应用

3、总结

上面几种单例模式的实现都各有优缺点，适用于不同的场景，不过双重检测和静态内部类能解决工作中大部分的问题，枚举虽然很有特色、很完美，但是工作中用的还是比较少的。我的建议是使用静态内部类，简单易懂。