单例模式完全剖析(3)---- 探究简单却又使人迷惑的单例模式

于 2008-06-02 10:33:00 发布 · 86 阅读 · 0
文章标签：

#log4j #Apache #IE #junit #多线程

本文详细介绍了Java中实现单例模式的方法，包括线程安全、类加载器处理、序列化等关键问题，并提供了单例注册表的具体实现。

使用注册表


使用一个单例类注册表可以：
在运行期指定单例类
防止产生多个单例类子类的实例
在例8的单例类中，保持了一个通过类名进行注册的单例类注册表：
例8带注册表的单例类
  1. importjava.util.HashMap;
  2. importorg.apache.log4j.Logger;
  4. publicclassSingleton{
  5. privatestaticHashMapmap=newHashMap();
  6. privatestaticLoggerlogger=Logger.getRootLogger();
  8. protectedSingleton(){
  9. //Existsonlytothwartinstantiation
  10. }
  11. publicstaticsynchronizedSingletongetInstance(Stringclassname){
  12. if(classname==null)thrownewIllegalArgumentException("Illegalclassname");
  13. Singletonsingleton=(Singleton)map.get(classname);
  15. if(singleton!=null){
  16. logger.info("gotsingletonfrommap:"+singleton);
  17. returnsingleton;
  18. }
  19. if(classname.equals("SingeltonSubclass_One"))
  20. singleton=newSingletonSubclass_One();
  21. elseif(classname.equals("SingeltonSubclass_Two"))
  22. singleton=newSingletonSubclass_Two();
  24. map.put(classname,singleton);
  25. logger.info("createdsingleton:"+singleton);
  26. returnsingleton;
  27. }
  28. //Assumefunctionalityfollowsthat'sattractivetoinherit
  29. }

这段代码的基类首先创建出子类的实例，然后把它们存储在一个Map中。但是基类却得付出很高的代价因为你必须为每一个子类替换它的getInstance()方法。幸运的是我们可以使用反射处理这个问题。

使用反射


在例9的带注册表的单例类中，使用反射来实例化一个特殊的类的对象。与例8相对的是通过这种实现，Singleton.getInstance()方法不需要在每个被实现的子类中重写了。
例9使用反射实例化单例类
  1. importjava.util.HashMap;
  2. importorg.apache.log4j.Logger;
  4. publicclassSingleton{
  5. privatestaticHashMapmap=newHashMap();
  6. privatestaticLoggerlogger=Logger.getRootLogger();
  8. protectedSingleton(){
  9. //Existsonlytothwartinstantiation
  10. }
  11. publicstaticsynchronizedSingletongetInstance(Stringclassname){
  12. Singletonsingleton=(Singleton)map.get(classname);
  14. if(singleton!=null){
  15. logger.info("gotsingletonfrommap:"+singleton);
  16. returnsingleton;
  17. }
  18. try{
  19. singleton=(Singleton)Class.forName(classname).newInstance();
  20. }
  21. catch(ClassNotFoundExceptioncnf){
  22. logger.fatal("Couldn'tfindclass"+classname);
  23. }
  24. catch(InstantiationExceptionie){
  25. logger.fatal("Couldn'tinstantiateanobjectoftype"+classname);
  26. }
  27. catch(IllegalAccessExceptionia){
  28. logger.fatal("Couldn'taccessclass"+classname);
  29. }
  30. map.put(classname,singleton);
  31. logger.info("createdsingleton:"+singleton);
  33. returnsingleton;
  34. }
  35. }


关于单例类的注册表应该说明的是：它们应该被封装在它们自己的类中以便最大限度的进行复用。

封装注册表


例10列出了一个单例注册表类。
例10一个SingletonRegistry类
  1. importjava.util.HashMap;
  2. importorg.apache.log4j.Logger;
  4. publicclassSingletonRegistry{
  5. publicstaticSingletonRegistryREGISTRY=newSingletonRegistry();
  7. privatestaticHashMapmap=newHashMap();
  8. privatestaticLoggerlogger=Logger.getRootLogger();
  10. protectedSingletonRegistry(){
  11. //Existstodefeatinstantiation
  12. }
  13. publicstaticsynchronizedObjectgetInstance(Stringclassname){
  14. Objectsingleton=map.get(classname);
  16. if(singleton!=null){
  17. returnsingleton;
  18. }
  19. try{
  20. singleton=Class.forName(classname).newInstance();
  21. logger.info("createdsingleton:"+singleton);
  22. }
  23. catch(ClassNotFoundExceptioncnf){
  24. logger.fatal("Couldn'tfindclass"+classname);
  25. }
  26. catch(InstantiationExceptionie){
  27. logger.fatal("Couldn'tinstantiateanobjectoftype"+
  28. classname);
  29. }
  30. catch(IllegalAccessExceptionia){
  31. logger.fatal("Couldn'taccessclass"+classname);
  32. }
  33. map.put(classname,singleton);
  34. returnsingleton;
  35. }
  36. }

注意我是把SingletonRegistry类作为一个单例模式实现的。我也通用化了这个注册表以便它能存储和取回任何类型的对象。例11显示了的Singleton类使用了这个注册表。
例11使用了一个封装的注册表的Singleton类
  1. importjava.util.HashMap;
  2. importorg.apache.log4j.Logger;
  4. publicclassSingleton{
  6. protectedSingleton(){
  7. //Existsonlytothwartinstantiation.
  8. }
  9. publicstaticSingletongetInstance(){
  10. return(Singleton)SingletonRegistry.REGISTRY.getInstance(classname);
  11. }
  12. }

上面的Singleton类使用那个注册表的唯一实例通过类名取得单例对象。
现在我们已经知道如何实现线程安全的单例类和如何使用一个注册表去在运行期指定单例类名，接着让我们考查一下如何安排类载入器和处理序列化。

Classloaders


在许多情况下，使用多个类载入器是很普通的--包括servlet容器--所以不管你在实现你的单例类时是多么小心你都最终可以得到多个单例类的实例。如果你想要确保你的单例类只被同一个的类载入器装入，那你就必须自己指定这个类载入器;例如：
  1. privatestaticClassgetClass(Stringclassname)
  2. throwsClassNotFoundException{
  3. ClassLoaderclassLoader=Thread.currentThread().getContextClassLoader();
  5. if(classLoader==null)
  6. classLoader=Singleton.class.getClassLoader();
  8. return(classLoader.loadClass(classname));
  9. }
  10. }

这个方法会尝试把当前的线程与那个类载入器相关联;如果classloader为null，这个方法会使用与装入单例类基类的那个类载入器。这个方法可以用Class.forName()代替。

序列化


如果你序列化一个单例类，然后两次重构它，那么你就会得到那个单例类的两个实例，除非你实现readResolve()方法，像下面这样：
例12一个可序列化的单例类
  1. importorg.apache.log4j.Logger;
  3. publicclassSingletonimplementsjava.io.Serializable{
  4. publicstaticSingletonINSTANCE=newSingleton();
  6. protectedSingleton(){
  7. //Existsonlytothwartinstantiation.
  8. }
  9. [b]privateObjectreadResolve(){
  10. returnINSTANCE;
  11. }[/b]}

上面的单例类实现从readResolve()方法中返回一个唯一的实例;这样无论Singleton类何时被重构，它都只会返回那个相同的单例类实例。
例13测试了例12的单例类：
例13测试一个可序列化的单例类
  1. importjava.io.*;
  2. importorg.apache.log4j.Logger;
  3. importjunit.framework.Assert;
  4. importjunit.framework.TestCase;
  6. publicclassSingletonTestextendsTestCase{
  7. privateSingletonsone=null,stwo=null;
  8. privatestaticLoggerlogger=Logger.getRootLogger();
  10. publicSingletonTest(Stringname){
  11. super(name);
  12. }
  13. publicvoidsetUp(){
  14. sone=Singleton.INSTANCE;
  15. stwo=Singleton.INSTANCE;
  16. }
  17. publicvoidtestSerialize(){
  18. logger.info("testingsingletonserialization...");
  19. [b]writeSingleton();
  20. Singletons1=readSingleton();
  21. Singletons2=readSingleton();
  22. Assert.assertEquals(true,s1==s2);[/b]}
  23. privatevoidwriteSingleton(){
  24. try{
  25. FileOutputStreamfos=newFileOutputStream("serializedSingleton");
  26. ObjectOutputStreamoos=newObjectOutputStream(fos);
  27. Singletons=Singleton.INSTANCE;
  29. oos.writeObject(Singleton.INSTANCE);
  30. oos.flush();
  31. }
  32. catch(NotSerializableExceptionse){
  33. logger.fatal("NotSerializableException:"+se.getMessage());
  34. }
  35. catch(IOExceptioniox){
  36. logger.fatal("IOException:"+iox.getMessage());
  37. }
  38. }
  39. privateSingletonreadSingleton(){
  40. Singletons=null;
  42. try{
  43. FileInputStreamfis=newFileInputStream("serializedSingleton");
  44. ObjectInputStreamois=newObjectInputStream(fis);
  45. s=(Singleton)ois.readObject();
  46. }
  47. catch(ClassNotFoundExceptioncnf){
  48. logger.fatal("ClassNotFoundException:"+cnf.getMessage());
  49. }
  50. catch(NotSerializableExceptionse){
  51. logger.fatal("NotSerializableException:"+se.getMessage());
  52. }
  53. catch(IOExceptioniox){
  54. logger.fatal("IOException:"+iox.getMessage());
  55. }
  56. returns;
  57. }
  58. publicvoidtestUnique(){
  59. logger.info("testingsingletonuniqueness...");
  60. Singletonanother=newSingleton();
  62. logger.info("checkingsingletonsforequality");
  63. Assert.assertEquals(true,sone==stwo);
  64. }
  65. }

前面这个测试案例序列化例12中的单例类，并且两次重构它。然后这个测试案例检查看是否被重构的单例类实例是同一个对象。下面是测试案例的输出：
  2. Buildfile:build.xml
  4. init:
  5. [echo]Build20030422(22-04-200311:32)
  7. compile:
  9. run-test-text:
  10. [java].INFOmain:testingsingletonserialization...
  11. [java].INFOmain:testingsingletonuniqueness...
  12. [java]INFOmain:checkingsingletonsforequality
  14. [java]Time:0.1
  16. [java]OK(2tests)

单例模式结束语


单例模式简单却容易让人迷惑，特别是对于Java的开发者来说。在这篇文章中，作者演示了Java开发者在顾及多线程、类载入器和序列化情况如何实现单例模式。作者也展示了你怎样才能实现一个单例类的注册表，以便能够在运行期指定单例类。
iteye_18688
关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值