Java实现单例的难点

有简单又高效的方法可以实现单例模式，但没有一种方式能在任何情况下都确保单例的完整性。

单例模式是指某个类只被实例化一次，用来表示全局或系统范围的组件。单例模式常用于日志记录、工厂、窗口管理器和平台组件管理等。我认为要尽量避免 使用单例模式，因为一旦实现就很难改变或重载，而且会造成编写测试用例困难、代码结构糟糕等问题。另外，下面文章中的单例模式是不安全的。

人们花大量的精力研究怎样更好地实现单例模式，但有一种简单高效的实现方法。然而，没有一种方法能在任何情况下都确保单例的完整性。阅读下文，看看你是否认同。

Final字段

这种方法将构造函数私有化，向外提供一个公有的static final对象：

 
 
    
  
  
  1. public class FooSingleton { 
    2. 
  
  
  2.     public final static FooSingleton INSTANCE = new FooSingleton(); 
    3. 
  
  
  3.     private FooSingleton() { } 
    4. 
  
  
  4.     public void bar() { } 
    5. 
  
  
  5. } 
    6.

类加载时，static对象被初始化，此时私有的构造函数被第一次也是最后一次调用。即使在类初始化前有多个线程调用此类，JVM也能保证线程继续运行时该类已完整初始化。然而，使用反射和setAccessible(true)方法，可以创建其他新的实例：

 
 
    
  
  
  1. Constructor[] constructors = FooSingleton.class.getDeclaredConstructors(); 
    2. 
  
  
  2. Constructor constructor = constructors[0]; 
    3. 
  
  
  3. constructor.setAccessible(true); 
    4. 
  
  
  4. FooSingleton spuriousFoo = (FooSingleton) constructor.newInstance(new Object[0]); 
    5.

我们需要修改构造函数，使其免于多次调用，例如当它被再次调用时抛出异常。如下这样修改FooSingleton构造函数，可以防范此类攻击：

 
 
    
  
  
  1. public class FooSingleton2 { 
    2. 
  
  
  2.     private static boolean INSTANCE_CREATED; 
    3. 
  
  
  3.     public final static FooSingleton2 INSTANCE = new FooSingleton2(); 
    4. 
  
  
  4.     private FooSingleton2() { 
    5. 
  
  
  5.         if (INSTANCE_CREATED) { 
    6. 
  
  
  6.             throw new IllegalStateException("You must only create one instance of this class"); 
    7. 
  
  
  7.         } else { 
    8. 
  
  
  8.             INSTANCE_CREATED = true; 
    9. 
  
  
  9.         } 
    10. 
  
  
  10.     } 
    11. 
  
  
  11.     public void bar() { } 
    12. 
  
  
  12. } 
    13.

这样看起来安全一些了，但其实要创建新的实例还是一样容易。我们只需修改INSTANCE_CREATED字段，再玩同样的把戏就可以了：

 
 
    
  
  
  1. Field f = FooSingleton2.class.getDeclaredField("INSTANCE_CREATED"); 
    2. 
  
  
  2. f.setAccessible(true); 
    3. 
  
  
  3. f.set(null, false); 
    4. 
  
  
  4. Constructor[] constructors = FooSingleton2.class.getDeclaredConstructors(); 
    5. 
  
  
  5. Constructor constructor = constructors[0]; 
    6. 
  
  
  6. constructor.setAccessible(true); 
    7. 
  
  
  7. FooSingleton2 spuriousFoo = (FooSingleton2) constructor.newInstance(new Object[0]); 
    8.

我们采取的任何防范措施都可能被绕过，所以此方案并不可行。

静态工厂

使用这种方法，公有的成员类似静态工厂：

 
 
    
  
  
  1. public class FooSingleton3 { 
    2. 
  
  
  2.     public final static FooSingleton3 INSTANCE = new FooSingleton3(); 
    3. 
  
  
  3.     private FooSingleton3() { } 
    4. 
  
  
  4.     public static FooSingleton3 getInstance() { return INSTANCE; } 
    5. 
  
  
  5.     public void bar() { } 
    6. 
  
  
  6. } 
    7.

getInstance()方法返回的永远是同一个对象引用。虽然这个方案也无法防范反射，但还是有它的一些优点。例如，可以在不改变API的情况下，改变单例的实现。getInstance()出现在几乎所有的单例实现中，它也标志着这真的是一个单例模式。

延迟加载的单例模式

（译者注：在软件工程中，Initialization-on-demand holder 这个习语指的就是延迟加载的单例模式，参见维基百科）

如果希望尽可能延迟单例的创建（懒汉式加载），可以使用延迟初始化方法，当getInstance()方法第一次调用时线程安全地创建单例。相比之前的方案当第一次引用该类时就创建单例（饿汉式加载），这是一个进步。如下：

 
 
    
  
  
  1. public class FooSingleton4 { 
    2. 
  
  
  2.     private FooSingleton4() { 
    3. 
  
  
  3.     } 
    4. 
  
  
  4.     public static FooSingleton4 getInstance() { 
    5. 
  
  
  5.         return FooSingleton4Holder.INSTANCE; 
    6. 
  
  
  6.     } 
    7. 
  
  
  7.     private static class FooSingleton4Holder { 
    8. 
  
  
  8.         private static final FooSingleton4 INSTANCE = new FooSingleton4(); 
    9. 
  
  
  9.     } 
    10. 
  
  
  10. } 
    11.

要小心序列化

如果单例实现了序列化，它就要面临另一个威胁。因此需要将所有字段声明为transient（这样它就不会被序列化）并提供一个自定义的readResolve()方法返回唯一实例INSTANCE的引用。

枚举

这里用枚举作为单例INSTANCE的容器：

 
 
    
  
  
  1. public enum FooEnumSingleton { 
    2. 
  
  
  2.     INSTANCE; 
    3. 
  
  
  3.     public static FooEnumSingleton getInstance() { return INSTANCE; } 
    4. 
  
  
  4.     public void bar() { } 
    5. 
  
  
  5. } 
    6.

根据Java语言规范8.9，“Enum的final克隆方法保证枚举永远无法被克隆，其特殊的序列化机制保证无法反序列化得到拷贝的对象。同时，还禁止利用反射对枚举进行实例化。保证了这四个方面，在枚举常量之外，就不会有其他同类的枚举实例存在。”

这样，我们似乎很简单地就防范了序列化、克隆和反射的攻击。第一次看到这段话，我立刻想要证明它是错的。如下代码所示，绕过这些保护是很容易的： 

 
 
    
  
  
  1. Constructor con = FooEnumSingleton.class.getDeclaredConstructors()[0]; 
    2. 
  
  
  2. Method[] methods = con.getClass().getDeclaredMethods(); 
    3. 
  
  
  3. for (Method method : methods) { 
    4. 
  
  
  4.      if (method.getName().equals("acquireConstructorAccessor")) { 
    5. 
  
  
  5.          method.setAccessible(true); 
    6. 
  
  
  6.          method.invoke(con, new Object[0]); 
    7. 
  
  
  7.      } 
    8. 
  
  
  8.   } 
    9. 
  
  
  9.   Field[] fields = con.getClass().getDeclaredFields(); 
    10. 
  
  
  10.   Object ca = null; 
    11. 
  
  
  11.   for (Field field : fields) { 
    12. 
  
  
  12.       if (field.getName().equals("constructorAccessor")) { 
    13. 
  
  
  13.           field.setAccessible(true); 
    14. 
  
  
  14.           ca = field.get(con); 
    15. 
  
  
  15.       } 
    16. 
  
  
  16.   } 
    17. 
  
  
  17.   Method method = ca.getClass().getMethod("newInstance", new Class[]{Object[].class}); 
    18. 
  
  
  18.   method.setAccessible(true); 
    19. 
  
  
  19.   FooEnumSingleton spuriousEnum = (FooEnumSingleton) method.invoke(ca, new Object[]{new Object[]{"SPURIOUS_INSTANCE", 1}}); 
    20. 
  
  
  20.   printInfo(FooEnumSingleton.INSTANCE); 
    21. 
  
  
  21.   printInfo(spuriousEnum); 
    22. 
  
  
  22. } 
    23. 
  
  
  23. private static void printInfo(FooEnumSingleton e) { 
    24. 
  
  
  24.     System.out.println(e.getClass() + ":" + e.name() + ":" + e.ordinal()); 
    25. 
  
  
  25. } 
    26.

执行这段代码，得到结果：

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实现单例的难点
新闻来源：http://www.shufengxianlan.com/qtweb/news38/451888.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

行业网站建设

重庆联通机房托管　　 　微信网站开发　　 　中国电信成都枢纽中心　　 　德阳东方电机技改　　 　成都光华机房　　 　郫都区消防器材　　 　网站seo优化　　 　温江网站建设　　 　成都企业网站建设　　 　外贸网站建设　　 　手机app　　 　重庆托管服务器　　 　优化排名　　 　成都网站建设推广　　 　成都网站推广　　 　四川电信高防服务器托管　　 　网络推广外包　　 　虚拟主机　　 　Google外贸推广　　 　成都网站优化