单例是应用开发中一种设计模式，主要应用场景为：当且仅当系统中只能保留一个对象时使用。本文提出4中可以在生产环境中使用的单例设计模式。推荐使用enum的方式。
应用场景
例如一下应用场景[1]：
1、 Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？
2、网站的浏览人数统计，一般也是采用单例模式实现，否则难以同步。
3、应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
//todo
在joshua block 的《effective java second edition》 一书中给出了三种单例设计模式
1、采用静态变量：
public class TaskManager { public static final TaskManager INSTANCE = new TaskManager (); private TaskManager (){} //... } |
这种写法使用了私有的构造方法。来保证只能有一个实例,但是这种方法也有例外情况，因为，你可以通过反射来调用私有构造方法。这个时候你可以抛出异常。以下代码仅作为参考。
public class TaskManager { public static final TaskManager INSTANCE = new TaskManager(); private TaskManager() { if (INSTANCE != null) { try { throw new Exception("An object already exists"); } catch (Exception e) { e.printStackTrace(); } } } //... } |
2、采用静态方法
public class TaskManager { private static final TaskManager INSTANCE = new TaskManager(); private TaskManager() {} public static TaskManager getINSTANCE() { return INSTANCE; } //... } |
3、采用enum的方式
这种模式是目前最佳的，因为：
1、JVM会保证enum不能被反射并且构造器方法只执行一次。
2、此方法无偿提供了序列化机制，绝对防止反序列化时多次实例化。
3、运行时（compile-time ）创建对象（懒加载） // todo 关于cmpile-time和run-time有时间我单独写一篇文章。
enum是jdk5的特性，现在（2017）web应用普遍在jdk6、7、8，所以可以放心使用。
目前最佳的方式是使用接口的方式(解耦):
interface Resource { Object doSomething(); } public enum SomeThing implements Resource { INSTANCE { @Override public Object doSomething() { return "I am a Singleton nstance"; } }; } class Demo { public static void main(String[] args) { System.out.println(SomeThing.INSTANCE.doSomething()); } } |
或者不使用接口的形式
public enum SomeThing { INSTANCE; public void doSomething() { System.out.println("INSTANCE = " + INSTANCE); } } class Demo { public static void main(String[] args) { SomeThing.INSTANCE.doSomething(); } } |
也有人用其他的方式，我对这种方法持强烈反对,具体可以参考文献4，以下代码仅做参考
class Resource { } public enum SomeThing { INSTANCE; private Resource instance; SomeThing() { instance = new Resource(); } public Resource getInstance() { return instance; } } class Demo { public static void main(String[] args) { System.out.println(SomeThing.INSTANCE.getInstance()); } } |
在其他文章中有提到“懒汉”、“恶汉”的名词，其实懒汉主要就是"懒"加载[注：指在使用时装载，不使用时不进行装载]
有人提出这种懒汉设计
public class Singleton { private static Singleton instance; private Singleton (){} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } |
很显然这种设计线程不安全，一般不会使用。
有人又提出了懒汉改进的方法，使其线程安全。
public class Singleton { private static Singleton instance; private Singleton (){} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } |
这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是,因为是重量级锁，效率很低。
于是有人提出了双重校验锁机制,这个用的也比较多。
下面代码就是用double checked locking 方法实现的单例，这里的getInstance()方法要检查两次，确保是否实例INSTANCE是否为null或者已经实例化了，这也是为什么叫double checked locking 模式。
/** * 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; } } |
