1.单例和多例的区别
http://www.cnblogs.com/zhangliang88/p/5388472.html
2.Java:单例模式的七种写法
http://www.blogjava.net/kenzhh/archive/2013/03/15/357824.html
3.Java Singleton
http://blog.csdn.net/penngrove/article/details/5753977
==============================================================================
【单例类的5种写法】
==============================================================================
1、饿汉方式
/** * 饿汉,初始化时即生成 * @author franciswmf *这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化, *虽然导致类装载的原因有很多种,在单例模式中大多数都是调用getInstance方法, *但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance显然没有达到lazy loading的效果。 */ public class TraditionalSingleton { private TraditionalSingleton(){ System.out.println("TraditionalSingleton constructor execute"); } private static TraditionalSingleton singleton=new TraditionalSingleton(); public static TraditionalSingleton getInstance(){ return singleton; } }
2、懒汉方式
/** * 懒汉,线程安全(但效率低) * @author franciswmf *这种写法能够在多线程中很好的工作,而且看起来它也具备很好的lazy loading, *但是,遗憾的是,效率很低,99%情况下不需要同步。 */ public class LazySingleton { private static LazySingleton instance; private LazySingleton(){ System.out.println("LazySingleton constructor execute"); } public static synchronized LazySingleton getInstance(){//加synchronized同步关键字 if(null==instance){ instance=new LazySingleton(); } return instance; } }
3、静态内部类方式
/** * 静态内部类方式 * @author franciswmf *这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程, *它跟第三种和第四种方式不同的是(很细微的差别):第三种和第四种方式是只要Singleton类被装载了, *那么instance就会被实例化(没有达到lazy loading效果),而这种方式是Singleton类被装载了, *instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时, *才会显示装载SingletonHolder类,从而实例化instance。想象一下,如果实例化instance很消耗资源, *我想让他延迟加载,另外一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载, *那么这个时候实例化instance显然是不合适的。这个时候,这种方式相比第三和第四种方式就显得很合理。 */ public class StaticInnerClassSingleton { private StaticInnerClassSingleton(){ System.out.println("StaticInnerClassSingleton constructor execute"); } private static class InnerFactory{ private static final StaticInnerClassSingleton instance=new StaticInnerClassSingleton();//内部类 } public static StaticInnerClassSingleton getInstance(){ return InnerFactory.instance; } }
4、双重校验锁方式
/** * 双重校验锁 * @author franciswmf *这个是Singleton3方式的升级版,俗称双重检查锁定, *详细介绍请查看:http://www.ibm.com/developerworks/cn/java/j-dcl.html *在JDK1.5之后,双重检查锁定才能够正常达到单例效果。 */ public class DoubleCheckSingleton { private DoubleCheckSingleton(){ System.out.println("DoubleCheckSingleton constructor execute"); } private volatile static DoubleCheckSingleton singleton; // public static DoubleCheckSingleton getInstance(){ if(singleton==null){ synchronized(DoubleCheckSingleton.class){ if(singleton==null){ singleton=new DoubleCheckSingleton(); } } } return singleton; } }
5、枚举方式
/** * 枚举 * 这种方式是Effective Java作者Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象, * 可谓是很坚强的壁垒啊,不过,个人认为由于1.5中才加入enum特性,用这种方式写不免让人感觉生疏,在实际工作中,我也很少看见有人这么写过。 * @author franciswmf * */ public enum EnumSingleton { INSTANCE; EnumSingleton(){ System.out.println("EnumSingleton constructor execute"); } }
====================================================================
【用Reflection + SetAccessable()来攻击单例,如果能创建出两份单例,就认为攻击成功】
====================================================================
public class ReflectionAttack { /** * 1-TraditionalSingleton-饿汉方式 * @throws Exception */ private static void attackTraditionalSingleton() throws Exception{ Class<TraditionalSingleton> class_a=TraditionalSingleton.class; Constructor<TraditionalSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); TraditionalSingleton obj=constructor_a.newInstance(); obj=TraditionalSingleton.getInstance(); } /** * 2-LazySingleton-懒汉方式 * @throws Exception */ private static void attackLazySingleton() throws Exception{ Class<LazySingleton> class_a=LazySingleton.class; Constructor<LazySingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); LazySingleton obj=constructor_a.newInstance(); obj=LazySingleton.getInstance(); } /** * 3-StaticInnerClassSingleton-静态内部类方式 * @throws Exception */ private static void attackStaticInnerClassSingleton() throws Exception{ Class<StaticInnerClassSingleton> class_a=StaticInnerClassSingleton.class; Constructor<StaticInnerClassSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); StaticInnerClassSingleton obj=constructor_a.newInstance(); obj=StaticInnerClassSingleton.getInstance(); } /** * 4-DoubleCheckSingleton-双重校验锁方式 * @throws Exception */ private static void attackDoubleCheckSingleton() throws Exception{ Class<DoubleCheckSingleton> class_a=DoubleCheckSingleton.class; Constructor<DoubleCheckSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); DoubleCheckSingleton obj=constructor_a.newInstance(); obj=DoubleCheckSingleton.getInstance(); } /** * 5-EnumSingleton-枚举方式 *Java的单例模式在Effective Java里面有权威的做法,就是用Enum。这是最完美的做法。它 *利用Java自身语言机制保证了内存中只有一份拷贝,同时它也让那些想通过Reflection + *setAccessable()的攻击单例的做法失败。 * @throws Exception */ private static void attackEnumSingleton() throws Exception{ Class<EnumSingleton> class_a=EnumSingleton.class; Constructor<EnumSingleton> constructor_a=class_a.getDeclaredConstructor(); constructor_a.setAccessible(true); EnumSingleton obj=constructor_a.newInstance(); obj=EnumSingleton.INSTANCE; } public static void main(String[] args) throws Exception { attackTraditionalSingleton();//输出2次 attackLazySingleton();//输出2次 attackStaticInnerClassSingleton();//输出2次 attackDoubleCheckSingleton();//输出2次 attackEnumSingleton();//抛出异常:NoSuchMethodException } }
输出结果console截图: