学习笔记--设计模式之单例模式

Java中单例模式是一种常见的设计模式，单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。
单例模式有以下特点：
1、单例类只能有一个实例；
2、单例类必须自己创建自己的唯一实例；
3、单例类必须给所有其他对象提供这一实例。

单例模式总结下来有五种写法：　
第一种：懒汉单例模式，线程不安全，不推荐使用

public class Singleton  {
    private static Singleton instance = null;
    private Singleton(){}

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

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。这种写法在单线程场景下可以安全使用，多线程应用中可以通过以下改写实现线程同步（添加同步锁synchronized）

public class Singleton  {
    private static Singleton instance = null;
    private Singleton(){}

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

这种方式的效率很低，99%情况下不需要同步。

第二种：饿汉单例模式，线程安全
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

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

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

第三种：静态内部类

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

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

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。

第四种：双重校验锁
这个是第一种方式改写版的升级版本，在JDK1.5之后，双重检查锁定才能够正常达到单例效果。

public class Singleton  
{
    private volatile static Singleton instance = null;
    private Singleton(){}

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

第五种：枚举方式
这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是这种方式让人感觉生疏，在实际工作中，很少看见有人这么写。

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

总结
一般来说我比较喜欢饿汉模式和静态内部类，简单易懂，而且在JVM层实现了线程安全（如果不是多个类加载器环境），一般的情况下，我会使用饿汉模式，只有在要明确实现lazy loading效果时才会使用内部类模式。另外，如果涉及到反序列化创建对象时我会试着使用枚举的方式来实现单例，不过，我一直会保证我的程序是线程安全的，而且我永远不会使用懒汉模式，如果有其他特殊的需求，我可能会使用双重校验方式毕竟，JDK1.5已经没有双重检查锁定的问题了。