单例模式是指某个类只被实例化一次，用来表示全局或系统范围的组件。单例模式常用于日志记录、工厂、窗口管理器和平台组件管理等。我认为要尽量避免使用单例模式，因为一旦实现就很难改变或重载，而且会造成编写测试用例困难、代码结构糟糕等问题。另外，下面文章中的单例模式是不安全的。
人们花大量的精力研究怎样更好地实现单例模式，但有一种简单高效的实现方法。然而，没有一种方法能在任何情况下都确保单例的完整性。阅读下文，看看你是否认同。
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）”，只需要增加新的枚举实例即可。例如，有了一个单例的缓存之后，你也许还想给缓存引入多个层次。
结论
尽管绕过单例的这些保护并不容易，但确实没有一种万无一失的方案。如果你有更好的方案，请不吝赐教！
枚举是实现单例模式的简单而又高效的方法。如果想要有继承或懒汉式加载，延迟初始化方案是不错的选择。
祝你的单例好运！