设计模式(四)----- 单态模式(Singleton)----(JAVA版)
2013-11-05 00:02
429 查看
单态模式(Singleton):
保证一个类仅有一个实例,只提供一个访问它的全局访问点
适用性:
1.当一个类只能有一个实例,而且客户可以从一个众所周知的访问点访问它
2.当这个唯一实例应该是通过子类化可扩展的,并且客户应该无需更改代码就能使用一个扩展的实例时
3.Singleton的应用有很多,譬如对数据库只能有一个连接,或者对网站的连接数的计数器。
一个简单的例子:
Singleton
[java]
view plaincopyprint?
public class Singleton{
private static Singleton sing;
private Singleton(){
}
public static Singleton getInstance(){
if(sing == null)
{
sing = new Singleton();
}
return sing;
}
}
Test
[java]
view plaincopyprint?
public class Test{
public static void main(String[] args){
Singleton sing = Singleton.getInstance();
Singleton sing2 = Singleton.getInstance();
System.out.println(sing);
System.out.println(sing2);
}
result:
singleton.Singleton@1c78e57
singleton.Singleton@1c78e57
单态模式的几种形势:
Snippet 1 基本形式是使用private constructor和一个public的static方法来获得类的实例。
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance() {
return instance;
}
}
constructor是private,所以如 Singleton s = new Singleton() 不再可行了。只能通过Singleton s = Singleton.getInstance(); 来获得实例,而这个实例因为是static,全局共享一个,所以无论有多少个Singleton s = Singleton.getInstance(); 得到的实例都是同一个。
Snippet 2 采用lazy initialization
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance() {
if(instance == null)
instance = new Singleton();
return instance;
}
}
Snippet 2同Snippet 1的区别在于:
Snippet 1在load class阶段就创建对象了;而Snippet 2只有第一次要实例化的时候才会创建对象。这就是所谓的lazy initialization。
多线程问题
我们来看snippet 2,如果是单线程,没问题,如果是多线程,问题就出现了,因为两个线程可以同时进入if(instance == null) 这个判断语句,所以有可能两个线程创建两个实例。
Snippet 3
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static synchronized Singleton getInstance() {
if(instance == null)
instance = new Singleton();
return instance;
}
}
然而Snippet 3的问题是在创建了对象之后, instance = new Singleton() 这个语句就再也不会执行了,所以对整个方法进行同步的话效率低下,这样就有人想出了Double-checked locking的方法:
Snippet 4
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance() {
if(instance == null)
synchronized(Singleton.class){
if(instance == null)
instance = new Singleton();
}
return instance;
}
}
这样就解决了问题,仅仅对:
[java]
view plaincopyprint?
if(instance == null)
instance = new Singleton();
这段代码进行同步,如果对象已经被创建,就不会进入到第一个if代码段里面,所以仅仅在第一次创建的时候会进行同步,效率自然高了。现在看来万无一失了。但问题还没有这么简单。
out-of-order write问题,更多相关资料请见:
DoubleCheckedLocking
instance = new Singleton(); 的顺序应该是
[java]
view plaincopyprint?
1 分配内存
2 构造函数初始化
3 将对象的reference赋值给instance
但因为Java Memory Model的问题,可能出现下面的所谓out-of-order write的问题:
[java]
view plaincopyprint?
1 分配内存
2 将对象的reference赋值给instance
3 构造函数初始化
也就是还没对对象初始化,就已经instance != null了,这样如果另外一个线程这时候对实例进行操作,可能有意想不到的结果。但仍旧没有好的办法可以完全解决这个问题。
综上,采用Snippet 1或者Snippet 3比较安全。Snippet 2和Snippet 4最好在多线程的环境下不要使用,否则可能会出错。
限制
但Singleton的模式还是有限制的
1 因为采用private constructor,所以Singleton是不能被继承的。
2 如果应用是在容器中运行,就要小心,因为servlet可能在被几个classloader加载,同时有几个Singleton实例存在。
3 另外如果Singleton是可被序列化的(Serializable),如果序列化一次而反序列化多次就有可能有多个Singleton实例存在。
保证一个类仅有一个实例,只提供一个访问它的全局访问点
适用性:
1.当一个类只能有一个实例,而且客户可以从一个众所周知的访问点访问它
2.当这个唯一实例应该是通过子类化可扩展的,并且客户应该无需更改代码就能使用一个扩展的实例时
3.Singleton的应用有很多,譬如对数据库只能有一个连接,或者对网站的连接数的计数器。
一个简单的例子:
Singleton
[java]
view plaincopyprint?
public class Singleton{
private static Singleton sing;
private Singleton(){
}
public static Singleton getInstance(){
if(sing == null)
{
sing = new Singleton();
}
return sing;
}
}
public class Singleton{ private static Singleton sing; private Singleton(){ } public static Singleton getInstance(){ if(sing == null) { sing = new Singleton(); } return sing; } }
Test
[java]
view plaincopyprint?
public class Test{
public static void main(String[] args){
Singleton sing = Singleton.getInstance();
Singleton sing2 = Singleton.getInstance();
System.out.println(sing);
System.out.println(sing2);
}
public class Test{ public static void main(String[] args){ Singleton sing = Singleton.getInstance(); Singleton sing2 = Singleton.getInstance(); System.out.println(sing); System.out.println(sing2); }
result:
singleton.Singleton@1c78e57
singleton.Singleton@1c78e57
单态模式的几种形势:
Snippet 1 基本形式是使用private constructor和一个public的static方法来获得类的实例。
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance() {
return instance;
}
}
public class Singleton { private static Singleton instance = new Singleton(); private Singleton(){} public static Singleton getInstance() { return instance; } }
constructor是private,所以如 Singleton s = new Singleton() 不再可行了。只能通过Singleton s = Singleton.getInstance(); 来获得实例,而这个实例因为是static,全局共享一个,所以无论有多少个Singleton s = Singleton.getInstance(); 得到的实例都是同一个。
Snippet 2 采用lazy initialization
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance() {
if(instance == null)
instance = new Singleton();
return instance;
}
}
public class Singleton { private static Singleton instance = null; private Singleton(){} public static Singleton getInstance() { if(instance == null) instance = new Singleton(); return instance; } }
Snippet 2同Snippet 1的区别在于:
Snippet 1在load class阶段就创建对象了;而Snippet 2只有第一次要实例化的时候才会创建对象。这就是所谓的lazy initialization。
多线程问题
我们来看snippet 2,如果是单线程,没问题,如果是多线程,问题就出现了,因为两个线程可以同时进入if(instance == null) 这个判断语句,所以有可能两个线程创建两个实例。
Snippet 3
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static synchronized Singleton getInstance() {
if(instance == null)
instance = new Singleton();
return instance;
}
}
public class Singleton { private static Singleton instance = null; private Singleton(){} public static synchronized Singleton getInstance() { if(instance == null) instance = new Singleton(); return instance; } }
然而Snippet 3的问题是在创建了对象之后, instance = new Singleton() 这个语句就再也不会执行了,所以对整个方法进行同步的话效率低下,这样就有人想出了Double-checked locking的方法:
Snippet 4
[java]
view plaincopyprint?
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance() {
if(instance == null)
synchronized(Singleton.class){
if(instance == null)
instance = new Singleton();
}
return instance;
}
}
public class Singleton { private static Singleton instance = null; private Singleton(){} public static Singleton getInstance() { if(instance == null) synchronized(Singleton.class){ if(instance == null) instance = new Singleton(); } return instance; } }
这样就解决了问题,仅仅对:
[java]
view plaincopyprint?
if(instance == null)
instance = new Singleton();
if(instance == null) instance = new Singleton();
这段代码进行同步,如果对象已经被创建,就不会进入到第一个if代码段里面,所以仅仅在第一次创建的时候会进行同步,效率自然高了。现在看来万无一失了。但问题还没有这么简单。
out-of-order write问题,更多相关资料请见:
DoubleCheckedLocking
instance = new Singleton(); 的顺序应该是
[java]
view plaincopyprint?
1 分配内存
2 构造函数初始化
3 将对象的reference赋值给instance
1 分配内存 2 构造函数初始化 3 将对象的reference赋值给instance
但因为Java Memory Model的问题,可能出现下面的所谓out-of-order write的问题:
[java]
view plaincopyprint?
1 分配内存
2 将对象的reference赋值给instance
3 构造函数初始化
1 分配内存 2 将对象的reference赋值给instance 3 构造函数初始化
也就是还没对对象初始化,就已经instance != null了,这样如果另外一个线程这时候对实例进行操作,可能有意想不到的结果。但仍旧没有好的办法可以完全解决这个问题。
综上,采用Snippet 1或者Snippet 3比较安全。Snippet 2和Snippet 4最好在多线程的环境下不要使用,否则可能会出错。
限制
但Singleton的模式还是有限制的
1 因为采用private constructor,所以Singleton是不能被继承的。
2 如果应用是在容器中运行,就要小心,因为servlet可能在被几个classloader加载,同时有几个Singleton实例存在。
3 另外如果Singleton是可被序列化的(Serializable),如果序列化一次而反序列化多次就有可能有多个Singleton实例存在。
相关文章推荐
- JAVA设计模式一---Singleton(单例模式)
- Java设计模式-单例模式(Singleton)
- 浅谈Java设计模式(三)单例模式(Singleton)
- Java设计模式之Singleton模式
- java设计模式之创建模式--singleton (demo)
- Java设计模式(5)Singleton模式 只有一个实例
- java设计模式---singleton---单例模式
- JAVA设计模式(03):创建型-单例模式(Singleton)
- Java设计模式透析之 —— 单例(Singleton)
- JAVA设计模式之三单例模式(Singleton)
- 设计模式之-单例模式(Singleton)及java中==与equals的区别
- 在 Java 中应用设计模式 -- Singleton
- java设计模式之Singleton(单态)
- java设计模式之单例模式(Singleton)
- Java设计设计模式之单例模式(Singleton)
- JAVA设计模式-单例模式(Singleton)线程安全与效率
- java 设计模式-singleton
- JAVA设计模式之Singleton
- Java设计模式透析之 —— 单例(Singleton)
- java设计模式之创建模式--singleton