设计模式（3）---单例模式

单例模式 Singleton （创建型模式）

1.定义

单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。

2.结构图

3.代码

懒汉式

 1 /*
 2  * 懒汉式
 3  * 实现了延迟创建和保证了线程安全
 4  */
 5 public class Singleton {
 6
 7     private static Singleton instance = null ;
 8
 9     private Singleton() {
10
11     }
12
13     public static synchronized Singleton getInstance(){
14         if (instance == null){
15             instance = new Singleton() ;
16         }
17         return instance ;
18     }
19
20 }

双重锁形式 

synchronized对整个方法加锁是没必要的，只要保证实例化对象的那段代码不被多线程同时访问就行了，当两个线程同时访问这个方法时，假设这时对象还没有被实例化，他们都可以通过第一重instance==null的判断，然后由于lock机制，这两个线程只有一个能进入，如果没有第二重的判断，则第一个线程创建了实例后，第二个线程还是可以继续再创建新的实例。

 1 /*
 2  * 双重锁形式
 3  *
 4  */
 5 public class Singleton {
 6
 7     private static Singleton instance = null ;
 8
 9     private Singleton() {
10
11     }
12
13     public static  Singleton getInstance(){
14         if (instance == null){
15             synchronized(Singleton.class){
16                 if (instance == null){
17                     instance = new Singleton() ;
18                 }
19             }
20         }
21         return instance ;
22     }
23
24 }

采用静态内部类的形式Java中静态内部类可以访问其外部类的成员属性和方法，同时，静态内部类只有当被调用的时候才开始首次被加载，利用此特性，可以实现懒汉式，在静态内部类中静态初始化外部类的单一实例即可。既是线程安全的，同时又提升了性能

 1 /*
 2  * 懒汉形式改进版   采用了静态内部类
 3  *
 4  */
 5 public class Singleton {
 6
 7     private Singleton() {
 8
 9     }
10     private static class LazyHolder{
11         private static final Singleton instance = new Singleton();
12     }
13
14     public static  Singleton getInstance(){
15         return LazyHolder.instance ;
16     }
17
18 }

饿汉形式

 1 /*
 2  * 饿汉形式
 3  *
 4  */
 5 public class Singleton {
 6
 7     private static final Singleton instance = new Singleton() ;
 8
 9     private Singleton() {
10
11     }
12
13     public static  Singleton getInstance(){
14         return instance ;
15     }
16
17 }

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

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

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

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