单例模式(Singleton Pattern)

单例模式（Singleton Pattern）是一种很常见的设计模式。核心就是保证系统中单例类只有一个实例。在系统中某些涉及配置数据，以及生成唯一序列ID的情况用的很多。

参考《设计模式之禅》中的定义：

Ensure a class has only one instance,and provide a global point of access to it.（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。）

简单的类图如下：

通过收集整理发现单例模式一共有8种写法。

1、饿汉 （静态常量）

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
    }

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

这种方式非常简单易懂。在类初始化的时候就回直接初始化出Singleton的实例。然后通过getInstance()方式来获取实例。不存在线程同步的问题。但是也存在一个缺点就是没有达到Lazy Loading的效果。

2、饿汉 （静态代码块）

public class Singleton {
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {
    }

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

和第一种方式差不多，使用静态代码块来创建单例类的实例。

3、懒汉模式（线程不安全）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

在我们项目里面之前用的很多，代码起到延迟加载的作用，但是线程不安全。如果一个线程走到 if (null == instance) 或者instance = new Singleton()的时候，还未真正实例化此类，此时如果另外一个线程走到if (null == instance)

instance此时还是null，将会导致产生多个实例，所以这种写法是线程不安全的。如果系统中对此单例类的调用存在多线程的情况，则不建议使用这种写法。

4、懒汉模式（在getInstance()方法加同步锁，线程安全）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

这种方法虽然加了线程同步，但是是加在整个方法体上面。导致效率地下，不推荐使用。

5、懒汉模式（在实例化单例类的时候加同步锁，线程不安全，还是有可能产生多个实例）

public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

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

比第四种方法效率高，看似加了同步锁，但是如果一个线程走到 if (null == instance) 的时候，此时如果另外一个线程走到if (null == instance)，instance此时还是null，还是会导致产生多个实例，所以这种写法也是线程不安全的。

6、双重检查

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
    }

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

双重检查，线程安全。且效率较高，推荐使用。

7、静态内部类

public class Singleton {
    private Singleton() {
    }

    private static class Instance {
        private final static Singleton INSTANCE = new Singleton();
    }

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

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载Instance类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

8、枚举

public enum Singleton {
    INSTANCE;

    public void doSomething() { // do something
    }
}

《Effective Java》和阎宏博士的《JAVA与模式》一书中非常推荐此方法。此方法是在JDK1.5中有枚举之后才出现的，实际使用的不多见。