double checked locking 实现法:
下面代码就是用double checked locking 方法实现的单例,这里的getInstance()方法要检查两次,确保是否实例INSTANCE是否为null或者已经实例化了,这也是为什么叫double checked locking 模式。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/**
* Singleton pattern example with Double checked Locking
*/
public
class
DoubleCheckedLockingSingleton{
private
volatile
DoubleCheckedLockingSingleton INSTANCE;
private
DoubleCheckedLockingSingleton(){}
public
DoubleCheckedLockingSingleton getInstance(){
if
(INSTANCE ==
null
){
synchronized
(DoubleCheckedLockingSingleton.
class
){
//double checking Singleton instance
if
(INSTANCE ==
null
){
INSTANCE =
new
DoubleCheckedLockingSingleton();
}
}
}
return
INSTANCE;
}
}
|
你可以使用 DoubleCheckedLockingSingleton.getInstance()来获取实例。
从创建一个lazy loaded thread-safe单例来看,它的代码行数与枚举相比,后者可以全部在一行内完成,因为枚举创建的单例在JVM层面上也能保证实例是thread-safe的。
静态工厂实现法:
这是我最喜欢的一种方式来实现单例模式,因为单例是静态的final变量,当类第一次加载到内存中的时候就初始化了,所以创建的实例固然是thread-safe。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/**
* Singleton pattern example with static factory method
*/
public
class
Singleton{
//initailzed during class loading
private
static
final
Singleton INSTANCE =
new
Singleton();
//to prevent creating another instance of Singleton
private
Singleton(){}
public
static
Singleton getSingleton(){
return
INSTANCE;
}
}
|
你可以调用Singleton.getSingleton()获取实例。这种非延迟加载,而是在启动时就加载好。
另外一个值得注意的点就是,传统单例存在的另外一个问题是一旦你实现了序列化接口,那么它们不再保持单例了,因为readObject()方法一直返回一个新的对象就像java的构造方法一样,你可以通过使用readResolve()方法来避免此事发生,看下面的例子:
1
2
3
4
|
//readResolve to prevent another instance of Singleton
private
Object readResolve(){
return
INSTANCE;
}
|
这样甚至还可以更复杂,如果你的单例类维持了其他对象的状态的话,因此你需要使他们成为transient的对象。但是枚举单例,JVM对序列化有保证。
关于readResolve()方法跟readObject()方法可以参见:
http://stackoverflow.com/questions/1168348/java-serialization-readobject-vs-readresolve
我对此的理解就是ReadObject方法会新生成一个新的实例,readResolve方法执行在readObject方法之后,用于替换生成的实例(与此对应的是writeReplace方法在writeObject方法之前),而当实现了该方法以后可以保证序列化后的唯一