Java单例模式

Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、枚举单例。
　　单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态。

懒汉式单例

第一种（线程不安全）

	public class Singleton {  
	     private static Singleton instance;  
	     private Singleton (){}  
	   
	     public static Singleton getInstance() {  
	     if (instance == null) {  
	     instance = new Singleton();  
	    }  
	   return instance;  
	 }  
 }  

这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。

第二种（线程安全）

	public class Singleton {  
	     private static Singleton instance;  
	     private Singleton (){}  
	     public static synchronized Singleton getInstance() {  
	     if (instance == null) {  
	         instance = new Singleton();  
	     }  
	     return instance;  
	     }  
	 }  

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，遗憾的是，效率很低，99%情况下不需要同步。

第三种（静态内部类）

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

这种比上面1、2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

第四种（双重校验锁）

	 public class Singleton {  
	     private volatile static Singleton singleton;  
	     private Singleton (){}  
	     public static Singleton getSingleton() {  
	     if (singleton == null) {  
	         synchronized (Singleton.class) {  
	         if (singleton == null) {  
	             singleton = new Singleton();  
	         }  
	         }  
	     }  
	     return singleton;  
	     }  
	 }  

这个是第二种方式的升级版，俗称双重检查锁定，在JDK1.5之后，双重检查锁定才能够正常达到单例效果。

饿汉式单例

	 public class Singleton {  
	     private static Singleton instance = new Singleton();  
	     private Singleton (){}  
	     public static Singleton getInstance() {  
	     return instance;  
	     }  
	 }  

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

用枚举来实现单例模式

目前最好的方式是用枚举来实现单例模式，如下： 

public enum Elvis {
INSTANCE("wangfabo", 1);
private final int id;
private final String name;
Elvis(String n, int i) {
   id=i;
   name=n;
}
public void leaveTheBuilding() {
   System.out.println("name:"+name+" id:"+id);;
}
public Elvis getInstance(){
   return INSTANCE;
}
}

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

饿汉式和懒汉式区别

1、从定义上比较：

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了；

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例；

2、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题；

懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的二、三、四，这三种实现在资源加载和性能方面有些区别；

3、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成；

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。