单例设计模式

    单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

　　单例模式有以下特点：

　　 1，单例模式使类在程序生命周期的任何时刻都只有一个实例，

        2，单例的构造函数是私有的，外部程序如果想要访问这个单例类的话，

        3，必须通过 GetInstance（）来请求（注意是请求）得到这个单例类的实例。

    单例模式一般有以下几种：    

一、懒汉式单例

[java] view plain copy

 print?

1. //懒汉式单例类.在第一次调用的时候实例化自己   
2. public class Singleton {  
3.     private Singleton() {}  
4.     private static Singleton single=null;  
5.     //静态工厂方法   
6.     public static Singleton getInstance() {  
7.          if (single == null) {    //if确保单线程情况下，对象只创建一次
8.              single = new Singleton();  
9.          }    
10.         return single;  
11.     }  
12. }  

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。

（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）

但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例。解决方法是三种：

1、在getInstance方法上加同步

[java] view plain copy

 print?

1. public static synchronized Singleton getInstance() {  
2.          if (single == null) {    
3.              single = new Singleton();  
4.          }    
5.         return single;  
6. }  

但是方法1还不是很完美，我们每次通过属性getInstance得到Sington的实例，都会试图加上一个同步锁，而加锁是一个非常耗时的操作。

2、双重检查锁定

[java] view plain copy

 print?

1. public static Singleton getInstance() {  
2.         if (singleton == null) {    
3.             synchronized (Singleton.class) {    
4.                if (singleton == null) {    
5.                   singleton = new Singleton();   
6.                }    
7.             }    
8.         }    
9.         return singleton;   
10.     }  

方法2，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗

3、静态内部类

[java] view plain copy

 print?

1. public class Singleton {    
2.     private static class LazyHolder {    
3.        private static final Singleton INSTANCE = new Singleton();    
4.     }    
5.     private Singleton (){}    
6.     public static final Singleton getInstance() {    
7.        return LazyHolder.INSTANCE;    
8.     }    
9. }    

利用了私有静态内部类的机制来保证初始化instance时只有一个线程，所以也是线程安全的，LazyHolder内部类只有属性Singleton.getInstance中被用到，由于其私有属性他人无法使用LazyHolder类，因此只有当我们第一次试图通过Singleton.getInstance得到Singleton的实例，会自动调用LacyHolder去创建实例instance，同时没有性能损耗。

二、饿汉式单例

[java] view plain copy

 print?

1. //饿汉式单例类.在类初始化时，已经自行实例化   
2. public class Singleton1 {  
3.     private Singleton1() {}  
4.     private static final Singleton1 single = new Singleton1();  
5.     //静态工厂方法   
6.     public static Singleton1 getInstance() {  
7.         return single;  
8.     }  
9. }  

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

饿汉式和懒汉式区别

1、线程安全：

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

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

2、资源加载和性能：

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

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