Singleton模式

   
   
        Singleton

        单件模式的使用意图就是：保证一个类仅有一个实例，并提供一个该实例全局的访问点.

        在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。还有singleton能够被状态化;

        这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。
      
        另外方面，Singleton也能够被无状态化。提供工具性质的功能， Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

        我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。

        现在来看一下应用.常用有如下两种形式,
 
        (一)
   

package  com.pattern.singleton;

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

        (二)

package  com.pattern.singleton;

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

        在单线程的情况下,(一),(二)可以较好的实现单例功能,然而在多线程时,可能会产生多个对象,如:
       
        # Thread 1 访问 getInstance() ,检测到 instance == null  //1.

        # Thread 1 执行到2,且尚未执行结束. //2.

        # 这时如果刚好有另一进程Thread 2访问getInstance(),并且也检测到了
instance == null. //1.

        # 那么当Thread 1 生成一个实例之后,Thread 2也会生成一个实例. //2.
 
        因而在多线程状态下要加上同步控制,如下:
   

package  com.pattern.singleton;

public   class  Safesingleton
... {
    private static volatile Safesingleton instance = null;
    private static final Object key = new Object();
    
    private Safesingleton()
    ...{
    }
   
    public void g()
    ...{
        System.out.println("I am in singleton.pulblic.g()");
    }
    
    public static Safesingleton getInstance()
    ...{
        if(instance == null)
        ...{
            // synchronized(Safesingleton.class)
             synchronized(key)
            ...{
                instance = new Safesingleton();
                return instance;
            }
        }
        return instance;
    }
}

        测试如下:
   

package com.pattern.singleton;
public   class  Testsingleton
... {
   public static void main(String[] args)
   ...{
       CSingleton sc1 = CSingleton.getInstance();
       CSingleton sc2 = CSingleton.getInstance();
       if(sc1==sc2)
         System.out.println("--------sc1==sc2-----------");
       if(sc1.equals(sc2))
          System.out.println("------sc1.equals(sc2)-------");
       
       Singleton s1 = Singleton.getInstance();
       Singleton s2 = Singleton.getInstance();
       if(s1==s2)
             System.out.println("--------s1==s2-----------");
           if(s1.equals(s2))
              System.out.println("------s1.equals(s2)-------");
       
       
       Safesingleton obj = Safesingleton.getInstance();
       Safesingleton sa =  Safesingleton.getInstance();
       if(obj==sa)
               System.out.println("--------obj==sa-----------");
             if(obj.equals(sa))
                System.out.println("------obj.equals(sa)-------");
   }
}

        结果如下:
   

--------sc1==sc2-----------
------sc1.equals(sc2)-------
--------s1==s2-----------
------s1.equals(s2)-------
--------obj==sa-----------
------obj.equals(sa)-------

   
        由此可以看出,单件模式实际上是控制对象创造过程来控制对象的创造个数的方法，单例子模式是只允许创建一个,我们可以对其进行扩展，让他只生成几个对象，这样可以实现对象池。