设计模式之单例（Java）

一提到单例，相信大家都不陌生了。单例就是确保一个类只有一个实例，并提供一个全局访问点。

单例模式虽然简单，在项目中很多人也在用它，但是不知道大家是否都已经正确的使用了，或者说其中的坑是否已经都知道。今天我就把自己所知道的单例模式做个总结。

单例模式的写法有很多，但是大概的可以分为两种：懒汉式和饿汉式。

第一种（懒汉，线程不安全）

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {

        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

这种写法很明显实现了lazy loading，但是它在多线程中是有问题的，有什么问题大家自己可以去思考。

第二种（懒汉，线程安全）

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {

        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

大家可以发现，这种方式跟第一种的区别是我们给getInstance()方法加锁同步了。这样一来，即实现了单例模式，且能在多线程中安全的工作。但是有个问题是该写法的效率很低。因为实际上我们只需要第一次创建Singleton实例的时候需要同步，当instance不为null的时候，我们是没有必要再同步的。

第三种（懒汉，双重校验锁，线程安全）

public class Singleton {

    private volatile static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {

        if(instance == null) {

            synchronized(Singleton.class) {

                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

这种方式是在第二种的基础之上，对instance用关键字volatile修饰。然后加锁是在方法内部当instance为null的时候再加锁，如果不为null则直接返回。这种方式的确实现了单例模式，并且线程安全，效率也不差。很不幸的是这种方式在java1.4以及更早的版本中，许多jvm对于volatile关键字的实现会导致双重校验加锁失效。所以这种方式在java1.4以上的版本是个不错的实现方式。

第四种（饿汉）

public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {

        return instance;
    }
}

这种方法基于ClassLoader机制避免了多线程的问题，但是实例化是在类加载的时候就进行了，即便你甚至没有用到该实例。所以没有实现lazy loading的效果。

第五中（静态内部类）

public class Singleton {

    private static class SingletonHolder {

        private static final Singleton INSTANCE = new 
        Singleton();

    }

    private Singleton() {};

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

}

这种方式也是靠ClassLoader机制来实例化一个对象的，它和第四种的区别很细微：第四种方式只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

针对ClassLoader机制的有一点得注意，就是不同的加载器加载类会实例化不同的单例对象出来，所以在这种多加载器的情况下，第四第五就会失效，但是也有相应的解决办法，这里就不说了。大家可以自行研究。

另外还有一种用枚举去实现单例模式的，这种方式用的少，这里就不做总结了。所以总的来说，我更喜欢用第五种方式来实现单例模式。如果是在java1.5以上版本，那么第三种双重校验锁也是一种不错的实现方式。

如果有什么说的不对的地方，也请各位大神指正！