单例模式的七种写法

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

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