单例模式的七种写法

单例模式的七种写法
第一种（懒汉，线程不安全）

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

lazy loading ，无线程同步处理（延迟加载(Lazy Loading)的意义在于只在需要的时候才去加载必要的数据，这样可以避免即时加载所带来的不必要的系统开销，这就符合了大多数人的要求）

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

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

可多线程处理，同lazy loading，但不需要同步次数较多，效率低

第三种（饿汉）

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

非lazy loading ，类装载时即初始化，基于classloader机制避免了多线程的问题

第四种（饿汉，变种）

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

同第三种，类初始化时实例化instance

第五种（静态内部类）

public class Singleton {    private static class SingletonHolder{        private static final Singleton instance= new Singleton();    }    private Singleton(){}    public static final Singleton getInstance(){            return SingletonHolder.instance;    }}

final变量可以安全的在多线程环境下进行共享，而不需要额外的同步开销。同时不为类加载时实例化，所以为lazy loading 。
当不需要lazy loading，可以直接使用第三种，需要是使用第五种

第六种（枚举）

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

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性

第七种(双重校验锁)

    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();            }        }    }}

双重校验锁仅在临界区加锁，synchronized 保证线程同步，volatile关键字保证不会出现另一个线程仅仅看到初始化到一半的instance的情况，使先行发生关系(happens-before relationship）,所有的写发生在读之前。

两个问题：
1、如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类 装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。
2、如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。

1修复

private static  class getClass(String classname) throws ClassNotFoundException{    ClassLoader classLoader =Thread.currentThread().getContextClassLoader();    if(classLoader==null)        classLoader=Singleton.class.getClassLoader();return(classLoader.class.getClassLoader());} 

2修复

public class Singleton implements jva.io.Serializable{    public static Singleton INSTANCE=new Singletton();    protected Singleton(){    }    private Object readResolve(){        return INSTANCE;    }}

总结：一般来说，前两种尽量不可用，三四为一种，这里没有lazy loading 直接使用第三种，需要的话使用第五种，第六种比较生疏研究透彻可以用，什么都不想的可以直接使用第七种。

来源：http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html

补充：C++中的第二种，第七种

public sealed class Singleton{    private Singleton(){}    private static Singleton instance=null;    public static Singleton getInstance{            Lock lock;                if(instance==null)                    instance=new Singleton();        }    }}

public sealed class Singleton{    private Singleton(){}    private static Singleton instance=null;    public static Singleton getInstance{        get{            if(instance==null){            Lock lock;                    if(instance==null)                        instance=new Singleton();                       }           }    }}