定义:
单例模式可分为有状态的和无状态的。有状态的单例对象一般也是可变的单例对象,多个单态对象在一起就可以作为一个状态仓库一样向外提供服务。没有状态的单例对象也就是不变单例对象,仅用做提供工具函数。
源码:
看这题目也许有点夸张,不过这对初学者是一个很好的警告。单例模式在java中的使用存在很多陷阱和假象,这使得没有意识到单例模式使用局限性的你在系统中布下了隐患……
其实这个问题早在2001年的时候就有人在网上系统的提出来过,我在这里只是老生常谈了。但是对于大多的初学者来说,可能这样的观点在还很陌生。下面我就一一列举出单例模式在java中存在的陷阱。
因此,在使用以上分布技术的系统中,应该避免使用存在状态的单例模式,因为一个有状态的单例类,在不同虚拟机上,各个单例对象保存的状态很可能是不一样的,问题也就随之产生。而且在EJB中不要使用单例模式来控制访问资源,因为这是由EJB容器来负责的。在其它的分布式系统中,当每一个虚拟机中的资源是不同的时候,可以考虑使用单例模式来进行管理。
当存在多个类加载器加载类的时候,即使它们加载的是相同包名,相同类名甚至每个字节都完全相同的类,也会被区别对待的。因为不同的类加载器会使用不同的命名空间(namespace)来区分同一个类。因此,单例类在多加载器的环境下会产生多个单例对象。
也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少见。在很多J2EE服务器上允许存在多个servlet引擎,而每个引擎是采用不同的类加载器的;浏览器中applet小程序通过网络加载类的时候,由于安全因素,采用的是特殊的类加载器,等等。
这种情况下,由状态的单例模式也会给系统带来隐患。因此除非系统由协调机制,在一般情况下不要使用存在状态的单例模式。
错误的同步处理
在使用上面介绍的懒汉式单例模式时,同步处理的恰当与否也是至关重要的。不然可能会达不到得到单个对象的效果,还可能引发死锁等错误。因此在使用懒汉式单例模式时一定要对同步有所了解。不过使用饿汉式单例模式就可以避免这个问题。
子类破坏了对象控制
在上一节介绍最后一种扩展性较好的单例模式实现方式的时候,就提到,由于类构造函数变得不再私有,就有可能失去对对象的控制。这种情况只能通过良好的文档来规范。
串行化(可序列化)
为了使一个单例类变成可串行化的,仅仅在声明中添加“implements Serializable”是不够的。因为一个串行化的对象在每次返串行化的时候,都会创建一个新的对象,而不仅仅是一个对原有对象的引用。为了防止这种情况,可以在单例类中加入readResolve方法。关于这个方法的具体情况请参考《Effective Java》一书第57条建议。
保证一个类仅有一个实例,并提供一个访问它的全局访问点。
类图:
单例模式可分为有状态的和无状态的。有状态的单例对象一般也是可变的单例对象,多个单态对象在一起就可以作为一个状态仓库一样向外提供服务。没有状态的单例对象也就是不变单例对象,仅用做提供工具函数。
源码:
饿汉式
/**
* 1.他们的构造函数都是私有的,彻底断开了使用构造函数来得到类的实例的通道,
* 但是这样也使得类失去了多态性(大概这就是为什么有人将这种模式称作单态模式)
* 2.就java语言来说,这种方式更符合java语言本身的特点。
*/
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {}
// 静态工厂方法,提供了一个供外部访问得到对象的静态方法
public static Singleton getInstance() {
return instance;
}
}
懒汉式
/**
* 1.对静态工厂方法进行了同步处理,原因很明显——为了防止多线程环境中产生多个实例;而在第一种方式中则不存在这种情况。
* 2.这种方式中将类对自己的实例化延迟到第一次被引用的时候。而在第一种方式中则是在类被加载的时候实例化,
* 这样多次加载会照成多次实例化。但是这种方式由于使用了同步处理,在反应速度上要比第一种慢一些。
*/
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 {
static class SingletonHolder {
static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
}
扩展:
以上两种实现方式均失去了多态性,不允许被继承。还有另外一种灵活点的实现,将构造函数设置为受保护的,这样允许被继承产生子类。这种方式在具体实现上又有所不同,可以将父类中获得对象的静态方法放到子类中再实现;也可以在父类的静态方法中进行条件判断来决定获得哪一个对象;在GOF中认为最好的一种方式是维护一张存有对象和对应名称的注册表(可以使用HashMap来实现)。下面的实现参考《java与模式》采用带有注册表的方式。
代码:
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
SingletonChildA.getInstance().test();
}
}
/**
* 单例模式(可扩展)
*/
public abstract class Singleton{
// 用来存放对应关系
private static HashMap<String,Object> sinRegistry = new HashMap<String,Object>();
// 受保护的构造函数
protected Singleton(){}
protected static Singleton getInstance(String name){
if (name == null)
name = "Singleton";
if (sinRegistry.get(name) == null){
try {
sinRegistry.put(name, Class.forName(name).newInstance());
} catch (Exception e){
e.printStackTrace();
}
}
return (Singleton) (sinRegistry.get(name));
}
public abstract void test();
}
public class SingletonChildA extends Singleton {
//单例
private SingletonChildA() {}
public static SingletonChildA getInstance(){
return (SingletonChildA) Singleton.getInstance("com.bestaone.pattern.singleton.SingletonChildA");
}
public void test(){
System.out.println("SingletonChildA test!");
}
}
看这题目也许有点夸张,不过这对初学者是一个很好的警告。单例模式在java中的使用存在很多陷阱和假象,这使得没有意识到单例模式使用局限性的你在系统中布下了隐患……
其实这个问题早在2001年的时候就有人在网上系统的提出来过,我在这里只是老生常谈了。但是对于大多的初学者来说,可能这样的观点在还很陌生。下面我就一一列举出单例模式在java中存在的陷阱。
多个虚拟机
当系统中的单例类被拷贝运行在多个虚拟机下的时候,在每一个虚拟机下都可以创建一个实例对象。在使用了EJB、JINI、RMI技术的分布式系统中,由于中间件屏蔽掉了分布式系统在物理上的差异,所以对你来说,想知道具体哪个虚拟机下运行着哪个单例对象是很困难的。因此,在使用以上分布技术的系统中,应该避免使用存在状态的单例模式,因为一个有状态的单例类,在不同虚拟机上,各个单例对象保存的状态很可能是不一样的,问题也就随之产生。而且在EJB中不要使用单例模式来控制访问资源,因为这是由EJB容器来负责的。在其它的分布式系统中,当每一个虚拟机中的资源是不同的时候,可以考虑使用单例模式来进行管理。
当存在多个类加载器加载类的时候,即使它们加载的是相同包名,相同类名甚至每个字节都完全相同的类,也会被区别对待的。因为不同的类加载器会使用不同的命名空间(namespace)来区分同一个类。因此,单例类在多加载器的环境下会产生多个单例对象。
也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少见。在很多J2EE服务器上允许存在多个servlet引擎,而每个引擎是采用不同的类加载器的;浏览器中applet小程序通过网络加载类的时候,由于安全因素,采用的是特殊的类加载器,等等。
这种情况下,由状态的单例模式也会给系统带来隐患。因此除非系统由协调机制,在一般情况下不要使用存在状态的单例模式。
错误的同步处理
在使用上面介绍的懒汉式单例模式时,同步处理的恰当与否也是至关重要的。不然可能会达不到得到单个对象的效果,还可能引发死锁等错误。因此在使用懒汉式单例模式时一定要对同步有所了解。不过使用饿汉式单例模式就可以避免这个问题。
子类破坏了对象控制
在上一节介绍最后一种扩展性较好的单例模式实现方式的时候,就提到,由于类构造函数变得不再私有,就有可能失去对对象的控制。这种情况只能通过良好的文档来规范。
串行化(可序列化)
为了使一个单例类变成可串行化的,仅仅在声明中添加“implements Serializable”是不够的。因为一个串行化的对象在每次返串行化的时候,都会创建一个新的对象,而不仅仅是一个对原有对象的引用。为了防止这种情况,可以在单例类中加入readResolve方法。关于这个方法的具体情况请参考《Effective Java》一书第57条建议。
其实对象的串行化并不仅局限于上述方式,还存在基于XML格式的对象串行化方式。这种方式也存在上述的问题,所以在使用的时候要格外小心。
思考:
以前遇到过这样一个问题“多线程下单例中的方法是不是阻塞式的”,我简单的认为是阻塞式的,认为一个线程在单例的方法中阻塞住了,那么后续的方法将同样被阻塞,但事实不是这样的(但使用synchronized可以实现)。
实例:
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
Thread t1 = new Thread(new UserA());
t1.start();
Thread t2 = new Thread(new UserB());
t2.start();
}
}
public class UserA implements Runnable{
@Override
public void run() {
Singleton.getInstance().print("A");
}
}
public class UserB implements Runnable{
@Override
public void run() {
Singleton.getInstance().print("B");
}
}
/**
* 单例
*/
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
/**
* 1.方法前不加synchronized,则输出为
* 进入:A
* 进入:B
* 离开:A
* 离开:B
* 2.方法前使用synchronized,则输出为(其一)
* 进入:A
* 进入:A
* 离开:B
* 离开:B
*
* 说明单例中的方法并不是独占式的,也就是方法阻不阻塞和是单例没有关系,
* 如果希望是阻塞的,那么就得使用synchronized
*/
public synchronized void print(String name){
System.out.println("进入:"+name);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("离开:"+name);
}
}