有简单又高效的方法可以实现单例模式,但没有一种方式能在任何情况下都确保单例的完整性。
单例模式是指某个类只被实例化一次,用来表示全局或系统范围的组件。单例模式常用于日志记录、工厂、窗口管理器和平台组件管理等。我认为要尽量避免使用单例模式,因为一旦实现就很难改变或重载,而且会造成编写测试用例困难、代码结构糟糕等问题。另外,下面文章中的单例模式是不安全的。
人们花大量的精力研究怎样更好地实现单例模式,但有一种简单高效的实现方法。然而,没有一种方法能在任何情况下都确保单例的完整性。阅读下文,看看你是否认同。
Final字段
这种方法将构造函数私有化,向外提供一个公有的static final对象:
1
2
3
4
5
|
public class FooSingleton {
public final static FooSingleton INSTANCE = new FooSingleton();
private FooSingleton() { }
public void bar() { }
} |
类加载时,static对象被初始化,此时私有的构造函数被第一次也是最后一次调用。即使在类初始化前有多个线程调用此类,JVM也能保证线程继续运行时该类已完整初始化。然而,使用反射和setAccessible(true)方法,可以创建其他新的实例:
1
2
3
4
|
Constructor[] constructors = FooSingleton. class .getDeclaredConstructors();
Constructor constructor = constructors[ 0 ];
constructor.setAccessible( true );
FooSingleton spuriousFoo = (FooSingleton) constructor.newInstance( new Object[ 0 ]);
|
我们需要修改构造函数,使其免于多次调用,例如当它被再次调用时抛出异常。如下这样修改FooSingleton构造函数,可以防范此类攻击:
1
2
3
4
5
6
7
8
9
10
11
12
|
public class FooSingleton2 {
private static boolean INSTANCE_CREATED;
public final static FooSingleton2 INSTANCE = new FooSingleton2();
private FooSingleton2() {
if (INSTANCE_CREATED) {
throw new IllegalStateException( "You must only create one instance of this class" );
} else {
INSTANCE_CREATED = true ;
}
}
public void bar() { }
} |
这样看起来安全一些了,但其实要创建新的实例还是一样容易。我们只需修改INSTANCE_CREATED字段,再玩同样的把戏就可以了:
1
2
3
4
5
6
7
|
Field f = FooSingleton2. class .getDeclaredField( "INSTANCE_CREATED" );
f.setAccessible( true );
f.set( null , false );
Constructor[] constructors = FooSingleton2. class .getDeclaredConstructors();
Constructor constructor = constructors[ 0 ];
constructor.setAccessible( true );
FooSingleton2 spuriousFoo = (FooSingleton2) constructor.newInstance( new Object[ 0 ]);
|
我们采取的任何防范措施都可能被绕过,所以此方案并不可行。
静态工厂
使用这种方法,公有的成员类似静态工厂:
1
2
3
4
5
6
|
public class FooSingleton3 {
public final static FooSingleton3 INSTANCE = new FooSingleton3();
private FooSingleton3() { }
public static FooSingleton3 getInstance() { return INSTANCE; }
public void bar() { }
} |
getInstance()方法返回的永远是同一个对象引用。虽然这个方案也无法防范反射,但还是有它的一些优点。例如,可以在不改变API的情况下,改变单例的实现。getInstance()出现在几乎所有的单例实现中,它也标志着这真的是一个单例模式。
延迟加载的单例模式
(译者注:在软件工程中,Initialization-on-demand holder 这个习语指的就是延迟加载的单例模式,参见维基百科)
如果希望尽可能延迟单例的创建(懒汉式加载),可以使用延迟初始化方法,当getInstance()方法第一次调用时线程安全地创建单例。相比之前的方案当第一次引用该类时就创建单例(饿汉式加载),这是一个进步。如下:
1
2
3
4
5
6
7
8
9
10
|
public class FooSingleton4 {
private FooSingleton4() {
}
public static FooSingleton4 getInstance() {
return FooSingleton4Holder.INSTANCE;
}
private static class FooSingleton4Holder {
private static final FooSingleton4 INSTANCE = new FooSingleton4();
}
} |
要小心序列化
如果单例实现了序列化,它就要面临另一个威胁。因此需要将所有字段声明为transient(这样它就不会被序列化)并提供一个自定义的readResolve()方法返回唯一实例INSTANCE的引用。
枚举
这里用枚举作为单例INSTANCE的容器:
1
2
3
4
5
|
public enum FooEnumSingleton {
INSTANCE;
public static FooEnumSingleton getInstance() { return INSTANCE; }
public void bar() { }
} |
根据Java语言规范8.9,“Enum的final克隆方法保证枚举永远无法被克隆,其特殊的序列化机制保证无法反序列化得到拷贝的对象。同时,还禁止利用反射对枚举进行实例化。保证了这四个方面,在枚举常量之外,就不会有其他同类的枚举实例存在。”
这样,我们似乎很简单地就防范了序列化、克隆和反射的攻击。第一次看到这段话,我立刻想要证明它是错的。如下代码所示,绕过这些保护是很容易的:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
Constructor con = FooEnumSingleton. class .getDeclaredConstructors()[ 0 ];
Method[] methods = con.getClass().getDeclaredMethods();
for (Method method : methods) {
if (method.getName().equals( "acquireConstructorAccessor" )) {
method.setAccessible( true );
method.invoke(con, new Object[ 0 ]);
}
}
Field[] fields = con.getClass().getDeclaredFields();
Object ca = null ;
for (Field field : fields) {
if (field.getName().equals( "constructorAccessor" )) {
field.setAccessible( true );
ca = field.get(con);
}
}
Method method = ca.getClass().getMethod( "newInstance" , new Class[]{Object[]. class });
method.setAccessible( true );
FooEnumSingleton spuriousEnum = (FooEnumSingleton) method.invoke(ca, new Object[]{ new Object[]{ "SPURIOUS_INSTANCE" , 1 }});
printInfo(FooEnumSingleton.INSTANCE);
printInfo(spuriousEnum);
} private static void printInfo(FooEnumSingleton e) {
System.out.println(e.getClass() + ":" + e.name() + ":" + e.ordinal());
} |
执行这段代码,得到结果:
1
2
|
class com.blogspot.minborgsjavapot.singleton.FooEnumSingleton:INSTANCE: 0
class com.blogspot.minborgsjavapot.singleton.FooEnumSingleton:SPURIOUS_INSTANCE: 1
|
枚举的缺点是它无法从另一个基类继承,因为它已经继承自java.lang.Enum。如果想要模拟这种继承,可以参考我另一篇文章中介绍的混入模式(mixin pattern)。
枚举的一个优点是,如果你之后希望有“二例(dualton)”或“三例(tringleton)”,只需要增加新的枚举实例即可。例如,有了一个单例的缓存之后,你也许还想给缓存引入多个层次。
结论
尽管绕过单例的这些保护并不容易,但确实没有一种万无一失的方案。如果你有更好的方案,请不吝赐教!
枚举是实现单例模式的简单而又高效的方法。如果想要有继承或懒汉式加载,延迟初始化方案是不错的选择。
祝你的单例好运!
相关推荐
Java实现单例模式[汇编].pdf
通过Java语言,主要实现了六种单例的生成方法,包括懒汉式、饿汉式、双重校验锁、枚举、静态内部类,可以根据实际情况选择使用
java Singleton单例模式 java Singleton单例模式
主要介绍了详解Java实现单例的五种方式,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式Java SE程序 单例模式...
实用Java的单例模式,实用于Java学习者 单例模式 单例模式
一个简单的java工程,包含注释,一目了然,其中包含了单例模式的所有实现方式,懒汉式,饿汉式,双重校验,枚举,静态内部类等方式实现单例。
Java中懒汉单例设计模式线程安全测试,单例设计模式的测试
作为对象的创建模式, 单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类譬如每台计算机可以有若干个打印机,但只能有一个Printer,以避免两个打印作业同时输出到打印机...
双重校验锁模式结合了懒汉模式和饿汉模式的优点,既实现了延迟加载,又保证了线程安全。你可以根据需求选择合适的单例模式实现方式。
主要介绍了Java实现单例设计模式方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
懒汉模式是延迟加载的方式,在首次调用getInstance()方法时才会创建实例;
饿汉模式在类加载时就创建了实例
java之单例模式
静态内部类模式结合了懒汉模式和饿汉模式的优点,既实现了延迟加载,又保证了线程安全。
Java设计模式-单例模式(懒汉和恶汉)
详细讲解了Java单例模式的几种实现方式,并有详细的示例配合讲解.
java单例模式的实现方式
单例模式是最简单的一种设计模式,确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例, 本资源提供了用java语言实现简单的单例模式,供初学者参考