单例模式（double checked locking+静态工厂+枚举）

double checked locking 实现法：

下面代码就是用double checked locking 方法实现的单例，这里的getInstance()方法要检查两次，确保是否实例INSTANCE是否为null或者已经实例化了，这也是为什么叫double checked locking 模式。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

/** * Singleton pattern example with Double checked Locking */ public class DoubleCheckedLockingSingleton{       private volatile DoubleCheckedLockingSingleton INSTANCE;         private DoubleCheckedLockingSingleton(){}         public DoubleCheckedLockingSingleton getInstance(){           if (INSTANCE == null ){              synchronized (DoubleCheckedLockingSingleton. class ){                  //double checking Singleton instance                  if (INSTANCE == null ){                      INSTANCE = new DoubleCheckedLockingSingleton();                  }              }           }           return INSTANCE;       } }

你可以使用 DoubleCheckedLockingSingleton.getInstance()来获取实例。

 

从创建一个lazy loaded thread-safe单例来看，它的代码行数与枚举相比，后者可以全部在一行内完成，因为枚举创建的单例在JVM层面上也能保证实例是thread-safe的。

 

静态工厂实现法：

这是我最喜欢的一种方式来实现单例模式，因为单例是静态的final变量，当类第一次加载到内存中的时候就初始化了，所以创建的实例固然是thread-safe。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/** * Singleton pattern example with static factory method */   public class Singleton{      //initailzed during class loading      private static final Singleton INSTANCE = new Singleton();        //to prevent creating another instance of Singleton      private Singleton(){}        public static Singleton getSingleton(){          return INSTANCE;      } }

你可以调用Singleton.getSingleton()获取实例。这种非延迟加载，而是在启动时就加载好。

 

另外一个值得注意的点就是，传统单例存在的另外一个问题是一旦你实现了序列化接口，那么它们不再保持单例了，因为readObject()方法一直返回一个新的对象就像java的构造方法一样，你可以通过使用readResolve()方法来避免此事发生，看下面的例子：

1 2 3 4

//readResolve to prevent another instance of Singleton      private Object readResolve(){          return INSTANCE;      }

这样甚至还可以更复杂，如果你的单例类维持了其他对象的状态的话，因此你需要使他们成为transient的对象。但是枚举单例，JVM对序列化有保证。

关于readResolve()方法跟readObject()方法可以参见：

http://stackoverflow.com/questions/1168348/java-serialization-readobject-vs-readresolve

我对此的理解就是ReadObject方法会新生成一个新的实例，readResolve方法执行在readObject方法之后，用于替换生成的实例（与此对应的是writeReplace方法在writeObject方法之前），而当实现了该方法以后可以保证序列化后的唯一