单例模式-高性能单例模式

使用volatile+双重检查实现高性能单例模式

public class Singleton {
    //此处使用volatile关键字避免过多线程进入synchronized同步方法
    private static volatile Singleton instance= null;
    private Singleton(){
    }
    //该方法使用了双重检查
    public Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

使用静态内部类实现的高性能单例模式

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

使用反射方法破坏单例模式，示例代码：

public class ReflectBrokenSingletonTest {
    public static void main(String[] args) throws Exception {
        Class<?> clazz=LazySingleton.class;
        Constructor c=clazz.getDeclaredConstructor(null);
        c.setAccessible(true);
        Object o1=c.newInstance();
        Object o2=c.newInstance();
        System.out.println(o1==o2);
    }
}

为避免单例模式被破坏，优化单例模式，代码如下：

public class LazySingleton {
    private static LazySingleton instance=null;
    private LazySingleton(){
        if(LazyHolder.lazy!=null){
            System.out.println("单例模式被破环");
            throw new RuntimeException("不允许创建多个实例");
        }
    }
    public static LazySingleton getInstance(){
        return LazyHolder.lazy;
    }
    private static class LazyHolder{
        private static final LazySingleton lazy=new LazySingleton();
    }
}