[原创]设计模型探索A-singleton pattern之唯我独尊

[原创]设计模型探索A-singleton pattern之唯我独尊

1.在何时使用:
   在某些情况下,我们只需要一个类只能实例化一个对象,在这种情况下,可以使用单件.
２.uml类图

３.使用单例模式的好处.
   单类的唯一实例由单件类本控制的,所以可以很好地控制只有一个实现.
　使用Singleton的好处还在于可以节省内存因为它限制了实例的个数,有利于Java垃圾回收（garbage collection）.

4.例子
　１）．饿汉式单件,

/** */ /**
 * <ul>
 * <li>Title:[SingletomA]</li>
 * <li>Description: [单例]</li>
 * <li>Copyright 2009 Upengs Co., Ltd.</li>
 * <li>All right reserved.</li>
 * <li>Created by [Huyvanpull] [2011-7-24]</li>
 * <li>Midified by [modifier] [modified time]</li>
 * </ul>
 * 
 * @version 1.0
 */
public   class  SingletomA
{
    private static SingletomA singletom = new SingletomA();
    
    private SingletomA()
    {}
    
    public static SingletomA getInstance()
    {
        return singletom;
    }
}

   2). 懒汉式单件
 

/** */ /**
 * <ul>
 * <li>Title:[SingletomB]</li>
 * <li>Description: [懒汉式单态]</li>
 * <li>Copyright 2009 Upengs Co., Ltd.</li>
 * <li>All right reserved.</li>
 * <li>Created by [Huyvanpull] [2011-7-24]</li>
 * <li>Midified by [modifier] [modified time]</li>
 * </ul>
 * @version 1.0  
 */
public   class  SingletomB
{
    
    private static SingletomB singletom;
    
    private SingletomB()
    {}
    
    public static SingletomB getInstance()
    {
        if (singletom == null)
        {
            singletom = new SingletomB();
        }
        return singletom;
    }
}

     这个单例模式是不安全的，为什么说呢 ？因为没考虑多线程，如下情况
     Thread 1 调用getInstance() 方法，并且判断instance是null，然後进入if模块，在实例化instance之前，Thread 2抢占了Thread 1的cpu。Thread 2 调用getInstance() 方法，并且判断instance是null，然後进入if模块，Thread 2 实例化instance 完成，返回Thread 1 再次实例化instance
        这个单例已经不在是单例
 
3).线程安全式单态
   

/** */ /**
 * <ul>
 * <li>Title:[SingletomB]</li>
 * <li>Description: [懒汉式单态]</li>
 * <li>Copyright 2009 Upengs Co., Ltd.</li>
 * <li>All right reserved.</li>
 * <li>Created by [Huyvanpull] [2011-7-24]</li>
 * <li>Midified by [modifier] [modified time]</li>
 * </ul>
 * @version 1.0  
 */
public   class  SingletomB
{
    
    private static SingletomB singletom;
    
    private SingletomB()
    {}
    
    public static synchronized SingletomB getInstance()
    {
        if (singletom == null)
        {
            singletom = new SingletomB();
        }
        return singletom;
    }
}

采用同步来解决，这种方式解决了问题，但是仔细分析正常的情况下只有第一次时候，进入对象的实例化，须要同步，其它时候都是直接返回已经实例化好的instance不须要同步，大家都知到在一个多线程的程序中，如果同步的消耗是很大的，很容易造成瓶颈.

4.改进型
利用Double-checked locking 两次同步，中间变量,解决上边的问题。

/** */ /**
 * <ul>
 * <li>Title:[SingletomB]</li>
 * <li>Description: [懒汉式单态]</li>
 * <li>Copyright 2009 Upengs Co., Ltd.</li>
 * <li>All right reserved.</li>
 * <li>Created by [Huyvanpull] [2011-7-24]</li>
 * <li>Midified by [modifier] [modified time]</li>
 * </ul>
 * 
 * @version 1.0
 */
public   class  SingletomB
{
    
    private static SingletomB singletom;
    
    private SingletomB()
    {}
    
    public static SingletomB getInstance()
    {
        if (singletom == null)
        {
            synchronized (SingletomB.class)
            {
                if (singletom == null)
                    singletom = new SingletomB();
            }
        }
        return singletom;
    }
}