设计模式-单例模式

定义

确保某一个类只有一个实例，而且自行实例化向整个系统提供这个实例。

单例模式的使用场景

在一个系统中，要求一个类有且仅有一个对象，如果出现多个对象就会出现“不良反 应”，可以采用单例模式，具体的场景如下：

• 要求生成唯一序列号的环境；
• 在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以 不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；
• 创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；
• 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。

饿汉模式

饿汉模式指类加载时就完成类的初始化，所以类加载较慢，获取实例较快，饿汉模式是线程安全的。

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

    private Singleton()
    {}

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

懒汉模式

懒汉模式在类加载的时候不初始化实例，只有调用getInstance方法的时候才判断是否存在实例，不存在则初始化实例。懒汉模式是线程不安全的。下面代码展示了最基本的懒汉模式。

public class Singleton_LanHan1
{
    private static Singleton_LanHan1 singleton = null;

    private Singleton_LanHan1()
    {}

    public static Singleton_LanHan1 getInstance()
    {
        if (singleton == null)
        {
            singleton = new Singleton_LanHan1();
        }
        return singleton;
    }
}

为什么懒汉模式是线程不安全的：当系统处于高并发状态下，一个程序走到if (singleton == null) 判断成功开始创建实例，但是实例创建是需要时间的，这时候另外一个程序也判断成功开始创建实例，这样就会产生两个实例，所以懒汉模式是线程不安全的。

解决懒汉模式线程不安全问题

getInstance方法加锁，解决了线程不安全问题，但是效率太低。

public class Singleton_LanHan2
{
    private static Singleton_LanHan2 singleton = null;

    private Singleton_LanHan2()
    {}

    public static synchronized Singleton_LanHan2 getInstance()
    {
        if (singleton == null)
        {
            singleton = new Singleton_LanHan2();
        }
        return singleton;
    }
}

懒汉模式之双重检查锁机制

public class Singleton_LanHan3
{
    private static Singleton_LanHan3 singleton;

    private Singleton_LanHan3()
    {}

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

解决线程不安全的方式有很多，但对于单例模式来说，不产生线程不安全的问题岂不是最好的解决方案? 所以推荐使用饿汉模式。