Java实现单例的难点

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

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

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

Final字段

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

public class FooSingleton {
    public final static FooSingleton INSTANCE = new FooSingleton();
    private FooSingleton() { }
    public void bar() { }
}

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

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

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

public class FooSingleton2 {
    private static boolean INSTANCE_CREATED;
    public final static FooSingleton2 INSTANCE = new FooSingleton2();
    private FooSingleton2() {
        if (INSTANCE_CREATED) {
            throw new IllegalStateException("You must only create one instance of this class");
        } else {
            INSTANCE_CREATED = true;
        }
    }
    public void bar() { }
}

这样看起来安全一些了，但其实要建立新的实例仍是同样容易。咱们只需修改INSTANCE_CREATED字段，再玩一样的把戏就能够了：

Field f = FooSingleton2.class.getDeclaredField("INSTANCE_CREATED");
f.setAccessible(true);
f.set(null, false);
Constructor[] constructors = FooSingleton2.class.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
FooSingleton2 spuriousFoo = (FooSingleton2) constructor.newInstance(new Object[0]);

咱们采起的任何防范措施均可能被绕过，因此此方案并不可行。

 

静态工厂

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

public class FooSingleton3 {
    public final static FooSingleton3 INSTANCE = new FooSingleton3();
    private FooSingleton3() { }
    public static FooSingleton3 getInstance() { return INSTANCE; }
    public void bar() { }
}

getInstance()方法返回的永远是同一个对象引用。虽然这个方案也没法防范反射，但仍是有它的一些优势。例如，能够在不改变API的状况下，改变单例的实现。getInstance()出如今几乎全部的单例实现中，它也标志着这真的是一个单例模式。

延迟加载的单例模式

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

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

public class FooSingleton4 {
    private FooSingleton4() {
    }
    public static FooSingleton4 getInstance() {
        return FooSingleton4Holder.INSTANCE;
    }
    private static class FooSingleton4Holder {
        private static final FooSingleton4 INSTANCE = new FooSingleton4();
    }
}

要当心序列化

若是单例实现了序列化，它就要面临另外一个威胁。所以须要将全部字段声明为transient（这样它就不会被序列化）并提供一个自定义的readResolve()方法返回惟一实例INSTANCE的引用。

 

枚举

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

public enum FooEnumSingleton {
    INSTANCE;
    public static FooEnumSingleton getInstance() { return INSTANCE; }
    public void bar() { }
}

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

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

Constructor con = FooEnumSingleton.class.getDeclaredConstructors()[0];
 Method[] methods = con.getClass().getDeclaredMethods();
 for (Method method : methods) {
     if (method.getName().equals("acquireConstructorAccessor")) {
         method.setAccessible(true);
         method.invoke(con, new Object[0]);
     }
  }
  Field[] fields = con.getClass().getDeclaredFields();
  Object ca = null;
  for (Field field : fields) {
      if (field.getName().equals("constructorAccessor")) {
          field.setAccessible(true);
          ca = field.get(con);
      }
  }
  Method method = ca.getClass().getMethod("newInstance", new Class[]{Object[].class});
  method.setAccessible(true);
  FooEnumSingleton spuriousEnum = (FooEnumSingleton) method.invoke(ca, new Object[]{new Object[]{"SPURIOUS_INSTANCE", 1}});
  printInfo(FooEnumSingleton.INSTANCE);
  printInfo(spuriousEnum);
}
private static void printInfo(FooEnumSingleton e) {
    System.out.println(e.getClass() + ":" + e.name() + ":" + e.ordinal());
}

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

class com.blogspot.minborgsjavapot.singleton.FooEnumSingleton:INSTANCE:0
class com.blogspot.minborgsjavapot.singleton.FooEnumSingleton:SPURIOUS_INSTANCE:1

枚举的缺点是它没法从另外一个基类继承，由于它已经继承自java.lang.Enum。若是想要模拟这种继承，能够参考我另外一篇文章中介绍的混入模式（mixin pattern）。

枚举的一个优势是，若是你以后但愿有“二例（dualton）”或“三例（tringleton）”，只须要增长新的枚举实例便可。例如，有了一个单例的缓存以后，你也许还想给缓存引入多个层次。

 

结论

尽管绕过单例的这些保护并不容易，但确实没有一种万无一失的方案。若是你有更好的方案，请不吝赐教！

枚举是实现单例模式的简单而又高效的方法。若是想要有继承或懒汉式加载，延迟初始化方案是不错的选择。

祝你的单例好运！

 

原文连接： dzone 翻译： rainsbaby
译文连接： http://www.importnew.com/16995.html