Java设计模式之单例模式

1、一般单例模式

一般单例模式口诀：两私一公。
具体说就是私有构造方法、私有静态实例、公开的静态获取方法。

1.1 懒汉式

public class LazySingleton {
    private static LazySingleton instance=null;
    private LazySingleton(){}
    /**
     * 在多线程的情况下会失效
     * 使用synchronized 同步锁，给getInstance()方法加锁
     */
    public static LazySingleton getInstance(){
        if(instance==null){
               instance=new LazySingleton();
        }
        return instance;
    }
}

1.2 饿汉式

public class HungrySingleton {
    //在自己内部定义自己的一个实例，只供内部调用
    private static final HungrySingleton instance = new HungrySingleton();
    private HungrySingleton(){}
    //这里提供了一个供外部访问本class的静态方法，可以直接访问
    public static HungrySingleton getInstance(){
        return instance;
    }
}

1.3 双重锁

/**
 * 双重锁volatile优化方式
 */
public class LockSingleton {
    /**
     * 指令重排序是为了优化指令，提高程序运行效率
     * volatile变量禁止指令重排序
     */
    private static volatile LockSingleton instance=null;
    private LockSingleton(){}
    /**
     * 同步是需要开销的，我们只需要在初始化的时候同步
     * @return
     */
    public static LockSingleton getInstance(){
        if (instance == null) {  
            synchronized (LockSingleton.class) {  
                if (instance == null) {  
                    instance = new LockSingleton();  
                }  
            }  
        } 
        return instance;
    }
}

2、反射攻击与枚举实现

2.1 反射攻击

上面介绍的三种单例模式都存在反射漏洞，比如下面反射攻击的例子。

import java.lang.reflect.Constructor;

public class ReflectDemo {
    public static void main(String[] args) {  
        //通过反射方法调用私有构造器  
        try {  
            Class<LazySingleton> clazz= (Class<LazySingleton>) Class.forName("singleton.LazySingleton");  
            Constructor<LazySingleton> constructor = clazz.getDeclaredConstructor(null);  
            constructor.setAccessible(true);  
            LazySingleton instance1 = constructor.newInstance();  
            LazySingleton instance2 = constructor.newInstance();  
            System.out.println(instance1);  
            System.out.println(instance2);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }         
    }
}

执行结果如下图所示，显然得到两个不同的对象。

2.2 解决办法

package singleton;
import java.lang.reflect.Constructor;

public class ReflectSingleton {
    private static ReflectSingleton instance=new ReflectSingleton();;
    private ReflectSingleton(){
        //可以在构造方法中手动抛出异常，解决反射漏洞问题  
        if(instance!=null){  
            throw new RuntimeException();  
        }
    }
    public static ReflectSingleton getInstance(){
        return instance;
    }   

    public static void main(String[] args) {
         System.out.println(ReflectSingleton.getInstance());
        //通过反射方法调用私有构造器  
        try {  
            Class<ReflectSingleton> clazz= (Class<ReflectSingleton>) Class.forName("singleton.ReflectSingleton");  
            Constructor<ReflectSingleton> constructor = clazz.getDeclaredConstructor(null);  
            constructor.setAccessible(true);  
            ReflectSingleton obj1 = constructor.newInstance();
            System.out.println(obj1);  
            ReflectSingleton obj2 = constructor.newInstance();
            System.out.println(obj2);
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }
}

执行结果

singleton.ReflectSingleton@15db9742
java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
    at java.lang.reflect.Constructor.newInstance(Unknown Source)
    at singleton.ReflectSingleton.main(ReflectSingleton.java:27)
Caused by: java.lang.RuntimeException
    at singleton.ReflectSingleton.<init>(ReflectSingleton.java:9)
    ... 5 more

2.3 枚举单例模式

（1）枚举单例模式

public enum EnumSingleton {
    INSTANCE {
        @Override
        protected void read() {
            System.out.println("read");
        }
        @Override
        protected void write() {
            System.out.println("write");
        }
    };
    protected abstract void read();
    protected abstract void write();
}

（2）测试程序

public class EnumSingletonDemo {
    public static void main(String[] args) {
        System.out.println(EnumSingleton.INSTANCE);
        System.out.println(EnumSingleton.INSTANCE);
        EnumSingleton.INSTANCE.read();
        EnumSingleton.INSTANCE.write();;
    }
}

运行结果

INSTANCE
INSTANCE
read
write

（3）枚举单例模式为什么可以防反射攻击？
这与枚举的实现有关，枚举本质上就是java类，我们对Singleton的class进行反编译，可以得到一个新的抽象类，因为我们定义的EnumSingleton中含有抽象方法。抽象类不能实例化，反射也无能为力。我靠，多么完美的解决方案啊！