Singleton模式实现及反射攻击

来源：互联网发布：maya动画导入unity3d 编辑：程序博客网时间：2024/05/17 15:36

1、singleton模式四种线程安全的实现

（1).Eager initialization 饿汉式单例类(依赖jvm在加载类时创建唯一单例实例)

public class EagerSingleton {          // jvm保证在任何线程访问uniqueInstance静态变量之前一定先创建了此实例          private static EagerSingleton uniqueInstance = new EagerSingleton();            // 私有的默认构造子，保证外界无法直接实例化          private EagerSingleton() {          }            // 提供全局访问点获取唯一的实例          public static EagerSingleton getInstance() {                  return uniqueInstance;          }  }

如果开销比较大，希望用到时才创建就要考虑延迟实例化,或者Singleton的初始化需要某些外部资源(比如网络或存储设备),就要用后面的方法了.
2)Lazy initialization 懒汉式单例类
public class LazySingleton {          private static LazySingleton uniqueInstance;            private LazySingleton() {          }            public static synchronized LazySingleton getInstance() {                  if (uniqueInstance == null)                          uniqueInstance = new LazySingleton();                  return uniqueInstance;          }  } 
同步一个方法可能造成程序执行效率下降100倍，完全没有必要每次调用getInstance都加锁，事实上我们只想保证一次初始化成功，其余的快速返回而已,如果在getInstance频繁使用的地方就要考虑重新优化了.
3)"双检锁"(Double-Checked Lock)尽量将"加锁"推迟,只在需要时"加锁"(仅适用于Java 5.0 以上版本,volatile保证原子操作) 
happens-before:"什么什么一定在什么什么之前运行",也就是保证顺序性.
现在的CPU有乱序执行的能力(也就是指令会乱序或并行运行,可以不按我们写代码的顺序执行内存的存取过程),并且多个CPU之间的缓存也不保证实时同步,只有上面的happens-before所规定的情况下才保证顺序性.
JVM能够根据CPU的特性(CPU的多级缓存系统、多核处理器等)适当的重新排序机器指令,使机器指令更符合CPU的执行特点，最大限度的发挥机器的性能.
如果没有volatile修饰符则可能出现一个线程t1的B操作和另一线程t2的C操作之间对instance的读写没有happens-before，可能会造成的现象是t1的B操作还没有完全构造成功，但t2的C已经看到instance为非空，这样t2就直接返回了未完全构造的instance的引用，t2想对instance进行操作就会出问题.
    volatile 的功能:
1. 避免编译器将变量缓存在寄存器里  
2. 避免编译器调整代码执行的顺序
优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。
public class DoubleCheckedLockingSingleton {          // java中使用双重检查锁定机制,由于Java编译器和JIT的优化的原因系统无法保证我们期望的执行次序。          // 在java5.0修改了内存模型,使用volatile声明的变量可以强制屏蔽编译器和JIT的优化工作          private volatile static DoubleCheckedLockingSingleton uniqueInstance;            private DoubleCheckedLockingSingleton() {          }            public static DoubleCheckedLockingSingleton getInstance() {                  if (uniqueInstance == null) {                          synchronized (DoubleCheckedLockingSingleton.class) {                                  if (uniqueInstance == null) {                                          uniqueInstance = new DoubleCheckedLockingSingleton();                                  }                          }                  }                  return uniqueInstance;          }  }  
4)Lazy initialization holder class 满足所有 Double-Checked Locking 满足的条件，并且没有显示的同步操作
public class LazyInitHolderSingleton {          private LazyInitHolderSingleton() {          }            private static class SingletonHolder {                  private static final LazyInitHolderSingleton INSTANCE = new LazyInitHolderSingleton();          }            public static LazyInitHolderSingleton getInstance() {                  return SingletonHolder.INSTANCE;          }  } 
根据jvm规范，当某对象第一次调用LazyInitHolderSingleton.getInstance()时，LazyInitHolderSingleton类被首次主动使用，jvm对其进行初始化（此时并不会调用LazyInitHolderSingleton()构造方法），然后LazyInitHolderSingleton调用getInstance()方法，该方法中，又首次主动使用了SingletonHolder类，所以要对SingletonHolder类进行初始化，初始化中，INSTANCE常量被赋值时才调用了 LazyInitHolderSingleton的构造方法LazyInitHolderSingleton()，完成了实例化并返回该实例。
当再有对象（也许是在别的线程中）再次调用LazyInitHolderSingleton.getInstance()时，因为已经初始化过了，不会再进行初始化步骤，所以直接返回INSTANCE常量即同一个LazyInitHolderSingleton实例。
单例模式的四种写法，并指出占位符模式的写法比较ok，详见如下：
package com.effective.singleton;public class Elvis{    private static boolean flag = false;    private Elvis(){    }    private  static class SingletonHolder{        private static final Elvis INSTANCE = new Elvis();    }    public static Elvis getInstance()    {        return SingletonHolder.INSTANCE;    }    public void doSomethingElse()    {    }}


2
、singleton模式四种线程安全的实现

 以上代码的实现都是基于一个条件：确保不会通过反射机制调用私有的构造器。
  但是举个例子，通过JAVA的反射机制来“攻击”单例模式：
package com.effective.singleton;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;public class ElvisReflectAttack{    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException    {        Class<?> classType = Elvis.class;        Constructor<?> c = classType.getDeclaredConstructor(null);        c.setAccessible(true);        Elvis e1 = (Elvis)c.newInstance();        Elvis e2 = Elvis.getInstance();        System.out.println(e1==e2);    }}
运行结果：false
可以看到，通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数，所有e1和e2是两个不同的对象。
如果要抵御这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。经修改后：
package com.effective.singleton;public class ElvisModified{    private static boolean flag = false;    private ElvisModified(){        synchronized(ElvisModified.class)        {            if(flag == false)            {                flag = !flag;            }            else            {                throw new RuntimeException("单例模式被侵犯！");            }        }    }    private  static class SingletonHolder{        private static final ElvisModified INSTANCE = new ElvisModified();    }    public static ElvisModified getInstance()    {        return SingletonHolder.INSTANCE;    }    public void doSomethingElse()    {    }}
    测试代码：
package com.effective.singleton;import java.lang.reflect.Constructor;public class ElvisModifiedReflectAttack{    public static void main(String[] args)    {        try        {            Class<ElvisModified> classType = ElvisModified.class;            Constructor<ElvisModified> c = classType.getDeclaredConstructor(null);            c.setAccessible(true);            ElvisModified e1 = (ElvisModified)c.newInstance();            ElvisModified e2 = ElvisModified.getInstance();            System.out.println(e1==e2);        }        catch (Exception e)        {            e.printStackTrace();        }    }}
运行结果：
Exception in thread "main" java.lang.ExceptionInInitializerError    at com.effective.singleton.ElvisModified.getInstance(ElvisModified.java:27)    at com.effective.singleton.ElvisModifiedReflectAttack.main(ElvisModifiedReflectAttack.java:17)Caused by: java.lang.RuntimeException: 单例模式被侵犯！    at com.effective.singleton.ElvisModified.<init>(ElvisModified.java:16)    at com.effective.singleton.ElvisModified.<init>(ElvisModified.java:7)    at com.effective.singleton.ElvisModified$SingletonHolder.<clinit>(ElvisModified.java:22)    ... 2 more
 可以看到，成功的阻止了单例模式被破坏。
    从JDK1.5开始，实现Singleton还有新的写法，只需编写一个包含单个元素的枚举类型。推荐写法：package com.effective.singleton;public enum SingletonClass{    INSTANCE;    public void test()    {        System.out.println("The Test!");    }}
 测试代码：package com.effective;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationTargetException;import com.effective.singleton.SingletonClass;public class TestMain{    public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException    {        Class<SingletonClass> classType = SingletonClass.class;        Constructor<SingletonClass> c = (Constructor<SingletonClass>) classType.getDeclaredConstructor();        c.setAccessible(true);        c.newInstance();    }}
运行结果：Exception in thread "main" java.lang.NoSuchMethodException: com.effective.singleton.SingletonClass.<init>()    at java.lang.Class.getConstructor0(Unknown Source)    at java.lang.Class.getDeclaredConstructor(Unknown Source)    at com.effective.TestMain.main(TestMain.java:22)

由此可见这种写法也可以防止单例模式被“攻击”。
而且这种写法也可以防止序列化破坏单例模式，具体不在举例了，有关序列化以及单例模式被序列化破坏可以参考博文《JAVA序列化》（链接：http://blog.csdn.net/u013256816/article/details/50474678）。
单元素的枚举类型已经成为实现Singleton模式的最佳方法。


参考文献:http://blog.csdn.net/u013256816/article/details/50525335

阅读全文

0 0