单例模式

意图

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

让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可、以被创建（通过截取创建新对象的请求） ，并且它可以提供一个访问该实例的方法。这就是Singleton模式

 

适用性

在下面的情况下可以使用S i n g l e t o n模式

• 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

• 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

 

Singleton模式有许多优点：

1) 对唯一实例的受控访问 因为Singleton类封装它的唯一实例，所以它可以严格的控制下载客户怎样以及何时访问它。

2) 缩小名空间 Singleton模式是对全局变量的一种改进。它避免了那些存储唯一实例的全局变量污染名空间。

3) 允许对操作和表示的精化Singleton类可以有子类，而且用这个扩展类的实例来配置一个应用是很容易的。你可以用你所需要的类的实例在运行时刻配置应用。

4) 允许可变数目的实例 这个模式使得你易于改变你的想法，并允许Singleton类的多个实例。此外，你可以用相同的方法来控制应用所使用的实例的数目。只有允许访问Singleton实例的操作需要改变。

5) 比类操作更灵活 另一种封装单件功能的方式是使用类操作。但这两种语言技术都难以改变设计以允许一个类有多个实例。

 

使用场合 

    简而言之，就是任何只需要一个实例的地方.例如，窗口管理器，假脱机打印设备，数据库连接池。具体应用中，配置信息类，管理类，控制类，门面类，代理类通常被设计为单例类. 

    （1）配置信息类 

    负责配置文件的解析，通常被设计为单例类 

    （2）管理类 

    如连接池管理类，通常被设计为单例类 

    （3）控制类 

    如struts的ActionServlet类，也是单例类。 

   如下，只需在web.xml配置以下ActionServlet,tomcat容器自动装载后，即可完成对整个web系统提供ActionServlet实例

（4）门面类 

    说到门面类，就不能不提门面（Facade）模式。客户端与多个子系统的通信必须通过一个统一的门面(Facade)对象进行，这就是门面模式。这个统一 的门面(Facade)对象就是门面类。在门面模式中，通常只需要一个门面类，并且此门面类只有一个实例，换言之它是一个单例类。但这不是绝对的。 
     （5）代理类 

    在Jive中，使用代理模式实现权限访问的入口，就采用了单例模式。 

 

 

单例的正确使用示例：
饿汉式单例类
饿汉式单例类是在Java 语言里实现得最为简便的单例类。在类被加载时，就会将自己实例化
 public class SingletonClass {
	private static class SingletonClassInstance {
		private static final SingletonClass instance = new SingletonClass();
	}
	public static SingletonClass getInstance() {
		return SingletonClassInstance.instance;
	}
	private SingletonClass() {
	}
}
懒汉式单例类 
双重检查锁定
 public class Singleton {
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance() {
        if (instance == null){
            synchronized(Singleton.class){
                if(instance == null) {
                     instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
(3)登记式单例类 
登记式单例类是GoF 为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的。

import java.util.HashMap; 
import org.apache.log4j.Logger; 
public class SingletonRegistry { 
   public static SingletonRegistry REGISTRY = new SingletonRegistry(); 
   private static HashMap map = new HashMap(); 
   private static Logger logger = Logger.getRootLogger(); 
   protected SingletonRegistry() { 
      // Exists to defeat instantiation 
   } 
   public static synchronized Object getInstance(String classname) { 
      Object singleton = map.get(classname); 
  
      if(singleton != null) { 
         return singleton; 
      } 
      try { 
         singleton = Class.forName(classname).newInstance(); 
         logger.info("created singleton: " + singleton); 
      } 
      catch(ClassNotFoundException cnf) { 
         logger.fatal("Couldn't find class " + classname);     
      } 
      catch(InstantiationException ie) { 
         logger.fatal("Couldn't instantiate an object of type " +  
                       classname);     
      } 
      catch(IllegalAccessException ia) { 
         logger.fatal("Couldn't access class " + classname);     
      } 
      map.put(classname, singleton); 
      return singleton; 
   } 
} 
使用：
import java.util.HashMap; 
import org.apache.log4j.Logger; 
  
public class Singleton { 
  
   protected Singleton() { 
      // Exists only to thwart instantiation. 
   } 
   public static Singleton getInstance() { 
      return (Singleton)SingletonRegistry.REGISTRY.getInstance(classname); 
   } 
}

 

jdk单例应用
1. JDK JAVA API 中的日历类型 Calendar  方法Calendar.getInstance();整个Jvm 系统中只需要一个 日历，构造方法都是protect，该类为抽象类
   public static Calendar getInstance()
    {
        Calendar cal = createCalendar(TimeZone.getDefaultRef(), Locale.getDefault());
	cal.sharedZone = true;
	return cal;
    }

2.java.lang.Runtime  典型的单例模式
public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    public static Runtime getRuntime() { 
		return currentRuntime;
    }
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
......
}

java.awt.Toolkit类，getDefaultToolkit()方法就是一个静态的方法。
public abstract class  Toolkit {
	。。。。。。
    private static Toolkit toolkit;
	。。。。。。
 public static synchronized Toolkit getDefaultToolkit() {
        if (toolkit == null) {
            try {
                // We disable the JIT during toolkit initialization.  This
                // tends to touch lots of classes that aren't needed again
                // later and therefore JITing is counter-productiive.
                java.lang.Compiler.disable();
                
                java.security.AccessController.doPrivileged(
                        new java.security.PrivilegedAction() {
                    public Object run() {
                        String nm = null;
                        Class cls = null;
                        try {
                            nm = System.getProperty("awt.toolkit", "sun.awt.X11.XToolkit");
                            try {
                                cls = Class.forName(nm);
                            } catch (ClassNotFoundException e) {
                                ClassLoader cl = ClassLoader.getSystemClassLoader();
                                if (cl != null) {
                                    try {
                                        cls = cl.loadClass(nm);
                                    } catch (ClassNotFoundException ee) {
                                        throw new AWTError("Toolkit not found: " + nm);
                                    }
                                }
                            }
                            if (cls != null) {
                                toolkit = (Toolkit)cls.newInstance();
                                if (GraphicsEnvironment.isHeadless()) {
                                    toolkit = new HeadlessToolkit(toolkit);
                                }
                            }
                        } catch (InstantiationException e) {
                            throw new AWTError("Could not instantiate Toolkit: " + nm);
                        } catch (IllegalAccessException e) {
                            throw new AWTError("Could not access Toolkit: " + nm);
                        }
                        return null;
                    }
                });
                loadAssistiveTechnologies();
            } finally {
                // Make sure to always re-enable the JIT.
                java.lang.Compiler.enable();
            }
        }
        return toolkit;
	}
	

 

 

 

 

http://www.iteye.com/topic/60179

http://www.ibm.com/developerworks/cn/java/j-dcl.html 

<!--EndFragment-->