(转)单例模式（Singleton Pattern）

Singleton模式的宗旨在于确保某个类只有一个实例, 并且为之提供一个全局访问点.

单例模式的应用场景:

     1.在资源管理方面的经常使用单例模式

        比如打印机的 Printer Spooler 是单例模式，这样可以避免两个作业同时输出到打印机.
    2.从系统性能方面考虑使用单例模式

       实例的创建是需要消耗系统资源的，而且是费时的，重复的对象最后还需要垃圾回收器回收，更是加重了系统的负担.

如何实现单例模式



       在设计单例模式的时候，首先要确定何时实例化该类的实例。第一种选择是将该单例对象作为单例类的一个静态域实例化。示例如下：

      

package com.zhaipuhong.designpattern;   
  
public class Singleton {   
    private static Singleton singleton = new Singleton();  //私有的本单例类的静态域   
       
    /**  
     * 私有的构造方法，阻止了用户通过此构造方法直接创建实例  
     */  
    private Singleton(){}   
       
    public Singleton getInstance(){   
        return singleton;   
    }   
}  
 

第二种情况，如果不希望提前创建单例对象，可以等到第一次使用该单例对象的时候再创建它。即惰性出初始化（lazy-initialize）。示例如下：

package com.zhaipuhong.designpattern;   
  
public class LazySingleton {   
    private static LazySingleton lazySingleton;  //私有的静态本单例域   
       
    private LazySingleton(){ } //私有的构造方法   
       
    public LazySingleton getInstance(){  //获取本单例的唯一实例   
        if(lazySingleton == null){   
            lazySingleton = new LazySingleton();     
        }   
        return lazySingleton;   
    }   
}  

        第二种方式存在的因为不仅仅是从一种语言技巧，是有实际需要的。当应用程序或系统在静态初始化阶段可能无法收集到足够的信息来实例化单例对象，有的需要等到运行时通过计算才能获得，这时候你就应该使用第二种方式。



        另外从系统性能和优化方面来讲，我更喜欢第二种方式，需要时再创建。







单例模式的扩展



        上述惰性单例模式在单线程环境是没有问题的。但是如果是在多线程环境必须小心了。在多线程环境，我们无法保证

一个方法能够持续执行到结束，其它线程的方法才开始。那么多个线程有可能在微小的时间段来同时尝试初始化单例类，此时他们都发现该单例实例尚为空。



        看起来我们需要对“检查单例对象是否已经被创建”进行同步，但是这样一来，所以的线程都必须等待这个检查过程的完成。这种同步会造成严重的性能瓶劲。示例代码如下：

package com.zhaipuhong.designpattern;   
  
public class SyncSingleton {   
    private static SyncSingleton syncSingleton;   
    private static final Object classLock = SyncSingleton.class;  //同步琐   
       
    private SyncSingleton(){}   
       
    public SyncSingleton getInstance(){   
        synchronized(classLock){   
            if(syncSingleton == null)   
                syncSingleton = new SyncSingleton();   
            return syncSingleton;   
        }   
    }   
}  

 

        另一种方法是我们在检查之后（if (instance == null)）再放置一些同步代码, 但是还是可能出现多个现成同时通过了检查。我们改进一下，检查之后，在同步代码中再检查一边，这样就是“双重锁定检查”模式了。它能将非必须的锁定优化掉。这里的同步检查最多发生一次。不会造成性能瓶劲。示例代码如下：

package com.zhaipuhong.designpattern;   
  
public class DoubleCheckedLocking {   
    private static DoubleCheckedLocking dcl;   
       
    private DoubleCheckedLocking(){}   
       
    private synchronized static void doSync(){   
        if(dcl == null)    
            dcl = new DoubleCheckedLocking();   
    }   
       
    public DoubleCheckedLocking getInstance(){   
        if(dcl == null)  //一重检查   
            doSync();    //同步的二重检查   
        return dcl;   
    }   
}