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中含有抽象方法。抽象类不能实例化,反射也无能为力。我靠,多么完美的解决方案啊!