学步园

package com.javapatterns.singleton.demos;
public class ClassUML {
　public ClassUML() {}

　private void aPrivateFunction() {}

　public void aPublicMethod() {}

　public int getAProperty(){ return aPrivateVar; }

　public void setAProperty(int aPrivateVar)
　 { this.aPrivateVar = aPrivateVar; 　}

　static public void aStaticMethod() {}

　protected void aProtectedMethod() {}

　private int aPrivateVar;
　public int aPublicVar;
　protected int aProtectedVar;
}

什么是创立性模式

　　创立性模式(Creational Patterns)是类在实例化时使用的模式。当一些系统在创立对象时,需要动态地决定 怎样创立对象,创立哪些对象。创立性模式告诉我们怎样构造和包装这些动态的决定。创立性模式通常包括 以下的模式

　　　1、工厂函数模式

　　　2、抽象工厂类模式

　　　3、建设者模式

　　　4、原始模型模式

　　　5、单态模式

　　单态模式

　　一个单态类只可有一个实例。这样的类常用来进行资源管理。

　　需要管理的资源包括软件外部资源，譬如，每台 计算机可以有若干个打印机，但只能有一个打印处理器软件。每台计算机可以有若干传真卡，但是 只应该有一个传真软件管理传真。每台计算机可以有若干通讯端口，你的软件应当集中管理这些 通讯端口，以避免同时一个通讯端口被两个请求同时调用。

　　需要管理的资源包括软件内部资源，譬如，大多数的软件都有一个(甚至多个)属性（properties）文件 存放系统配置。这样的系统应当有一个对象来管理一个属性文件。很多软件都有数据库，一般而言， 整个软件应当使用一个联接通道，而不是任意在需要时就新打开一个联接通道。

　　需要管理的软件内部资源也包括譬如负责纪录网站来访人数的部件,记录软件系统内部事件、出错 信息的部件，或是进行系统表现监查的的部件,等等。这些部件都必须集中管理，不可政出多头。

　　单态类的特性

　　综合而言，

　　　1、单态类只可有一个实例。

　　　2、它必须自己创立自己这唯一的一个实例。

　　　3、它必须给所有其它的类提供自己这一实例。

　　最后，单态类在理论和实践上都并非限定只能有"一个"实例,而是很容易推广到任意有限个实例的情况。

单态模式的几种实现

　　由于爪哇语言的特点,使得单态模式在爪哇语言的实现有自己的特点。这些特点主要表现在怎样实例化上。

　　饿汉式单态类

　　饿汉式单态类是在爪哇语言里实现得最为简便的单态类。

图2.饿汉式单态类的UML类图

　　图中的关系线表明,此类自已将自己实例化。

　　　　　　　　　　　　　　代码清单2.饿汉式单态类。

　　值得指出的是,由于构造子是私有的,因此此类不能被继承。

懒汉式单态类

　　懒汉式单态类在第一次被引用时将自己实例化。如果加载器是静态的,那么在懒汉式单态类被加载时不 会将自己实例化。

　　　　　　　　　　　　　　　　代码清单3.懒汉式单态类。

图3.懒汉式单态类

　　图中的关系线表明,此类自已将自己实例化。

　　读者可能会注意到，在上面给出 懒汉式单态类实现里,使用了在多线程编程中常要使用的，著名的双重检查原则。对双重检查原则 和多线程编程要点不十分熟悉的读者，可以看看后面给出的问答题。

　　同样,由于构造子是私有的,因此此类不能被继承。

　　饿汉式单态类在自己被加载时就将自己实例化。既便加载器是静态的,在饿汉式单态类被加载时仍 会将自己实例化。单从资源利用效率角度来讲,这是比懒汉式单态类稍差些。从速度和反应时间角度来 讲,则比懒汉式单态类稍好些。然而,懒汉式单态类在实例化时必须处理好在多个线程同时首次引 用此类时,实例化函数内部关键段的访问限制问题。特别是当单态类作为资源控器,在实例化时必然涉及 资源初始化,而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引 用此类的几率变得较大。

　　饿汉式单态类可以在爪哇语言内实现,但不易在C++内实现,因为静态初始化在C++里没有固定的顺序, 因而静态的m_instance变量的初始化与类的加载顺序没有保证,可能会出问题。这就是为什么GoF在提出 单态类的概念时,举的例子是懒汉式的。他们的书影响之大,以致爪哇语言中单态类的例子也大多是 懒汉式的。实际上，作者认为饿汉式单态类更符合爪哇语言本身的特点

public class RegSingleton {

　protected RegSingleton() {}

　static public RegSingleton getInstance(String name)
　{
　　if (name == null)
　　{
　　　name = "com.javapatterns.singleton.demos.RegSingleton";
　　}

　　if (m_registry.get(name) == null)
　　{
　　　try
　　　{
　　　　m_registry.put( name, Class.forName(name).newInstance() ) ;
　　　}
　　　catch(Exception e)
　　　{
　　　　System.out.println("Error happened.");
　　　}
　　}
　　return (RegSingleton) (m_registry.get(name) );
　}

　static private HashMap m_registry = new HashMap();

　static
　{
　　RegSingleton x = new RegSingleton();
　　m_registry.put( x.getClass().getName() , x);
　}

　public String about()
　{
　　return "Hello, I am RegSingleton.";
　}

}

　static public RegSingletonChild getInstance()
　{
　　return (RegSingletonChild) RegSingleton.getInstance(
　　　　　 "com.javapatterns.singleton.demos.RegSingletonChild" );
　}

　public String about()
　{
　　return "Hello, I am RegSingletonChild.";
　}

}

/**
* This class keeps your objects from garbage collected
*/
public class ObjectKeeper extends Thread {

　private ObjectKeeper()
　{
　　new Thread(this).start();
　}

　public void run()
　{
　　try { join(); }
　　catch (InterruptedException e) {}
　}

　/**
　* Any object passed here will be kept until you call discardObject()
　*/
　public static void keepObject(Object myObject)
　{
　　System.out.println(" Total number of kept objects: " +
　　　　　　　　　　　　 m_keptObjects.size());
　　m_keptObjects.add(myObject);
　　System.out.println(" Total number of kept objects: " +
　　　　　　　　　　　　　m_keptObjects.size());
　}

　/**
　* This method will remove the protect of the object you pass in and make it
　* available for Garbage Collector to collect.
　*/
　public static void discardObject(Object myObject)
　{
　　System.out.println(" Total number of kept objects: " +
　　　　　　　　　　　　m_keptObjects.size());
　　m_keptObjects.remove(myObject);
　　System.out.println(" Total number of kept objects: " +
　　　　　　　　　　　　m_keptObjects.size());
　}

　private static ObjectKeeper m_keeper = new ObjectKeeper();
　private static Vector m_keptObjects = new Vector();
}

public class ConfigManager
{
　/**
　* 私有的构造子, 用以保证实例化的唯一性
　*/
　private ConfigManager()
　{
　　m_file = new File(PFILE);
　　m_lastModifiedTime = m_file.lastModified();

　　if(m_lastModifiedTime == 0)
　　{
　　　System.err.println(PFILE + " file does not exist!");
　　}

　　m_props = new Properties();
　
　　try
　　{
　　　m_props.load(new FileInputStream(PFILE));
　　}
　　catch(Exception e)
　　{
　　　e.printStackTrace();
　　}
　}

　/**
　*
　* @return 返还ConfigManager类的单一实例
　*/
　synchronized public static ConfigManager getInstance()
　{
　　return m_instance;
　}

　/**
　* 读取一特定的属性项
　*
　* @param name 属性项的项名
　* @param defaultVal 属性项的缺省值
　* @return 属性项的值(如此项存在), 缺省值(如此项不存在)
　*/
　final public Object getConfigItem(String name, Object defaultVal)
　{
　　long newTime = m_file.lastModified();

　　// 检查属性文件是否被其它程序(多数情况是程序员手动)修改过。
　　// 如果是，重新读取此文件。
　　if(newTime == 0)
　　{
　　　// 属性文件不存在
　　　if(m_lastModifiedTime == 0)
　　　{
　　　　System.err.println(PFILE + " file does not exist!");
　　　}
　　　else
　　　{
　　　　System.err.println(PFILE + " file was deleted!!");
　　　}
　　　return defaultVal;
　　}
　　else if(newTime > m_lastModifiedTime)
　　{
　　　m_props.clear(); // Get rid of the old properties
　　　try
　　　{
　　　　m_props.load(new FileInputStream(PFILE));
　　　}
　　　catch(Exception e)
　　　{
　　　　e.printStackTrace();
　　　}
　　}
　　m_lastModifiedTime = newTime;

　　Object val = m_props.getProperty(name);
　　if( val == null )
　　{
　　　return defaultVal;
　　}
　　else
　　{
　　　return val;
　　}
　}

　/**
　* 属性文件全名
　*/
　private static final String PFILE = System.getProperty("user.dir")
　　　　　　　　　　　　　　　　　　　+ "/Singleton.properties";

　/**
　* 对应于属性文件的文件对象变量
　*/
　private File m_file = null;

　/**
　* 属性文件的最后修改日期
　*/
　private long m_lastModifiedTime = 0;

　/**
　* 属性文件所对应的属性对象变量
　*/
　private Properties m_props = null;

　/**
　* 本类可能存在的唯一的一个实例
　*/
　private static ConfigManager m_instance = new ConfigManager();

　}

ObjectKeeper.discardObject(ConfigManager.getInstance());

图8. 代码运行时的情况

问答题

　　1、为什么不使用一个静态的"全程"变量，而要建一个类？一个静态的变量当然只能有一个值， 从而自然而然不就是"单态"的吗？

　　2、在LazySingleton的例子中,如果把限制访问的关键词从LazySingleton.class移到getInstance() 方法的声明语句中,会怎样?

　
　　　　　　　　　　　　　　　　　　代码清单10.懒汉式单态类的变种。

　　3、在LazySingleton的例子中,出现了两层检查 if (m_instance == null)。这是否必要？如果将内层的检查去掉，会出问题吗？

　　4、同上，如果将外层的检查去掉，会出问题吗？

　　5、举例说明如何调用EagerSingleton类。

　　6、举例说明如何调用RegSingleton类和RegSingletonChild类。

　　7、在看守类中，变量m_keptObjects还可选择什么数据类型，使得程序占用更小？

　　8、设法用实例生成的时间，实例的identityHashCode，类加载器，实例的总数，实例化的序数 来确定一个单态确实是单态。

　　问答题答案

　　1、一个变量不能自已初始化,不可能有继承的关系。在爪哇语言里并没有真正的"全程"变量， 一个变量必须属于某一个类。而在复杂的程序当中，一个静态变量的 初始化发生在哪里，常常是一个不易确定的问题。当然，使用变量并没有什么错误，就好选择使用Fortran 语言而非爪哇语言编程并不是一种对错的问题一样。

　　2、这样做不会出错，但是效率不好。在原来的源代码中，synchronized行为只在第一次调用 此方法起作用,以后的调用均不会遇到。而在这里，任何凋用都会遇到synchronized的限制,这无异于 人为制造一个不必要的独木桥，十分愚蠢。

　　3、这样做一定会出问题。在第一次调用getInstance()时可能有多个线程几乎同时到达, 只有一个线程能到达内层检 查之内，其它的线程会在synchronized()语句处等待。这样当第一线程完成实例化之后,等待在 synchronized()语句处的其它线程会逐一获准进入synchronized()之后的语句。如果那里没有第二 次检查，它们就会逐一试图进行实例化，而这是错的。

　　4、这样不会出问题，但是效率不好，十分愚蠢。道理与第一题类似。

　　5、　

　　　　　　　　　　　代码清单11. 几种单态类的使用方法。

　　6、见上题答案。

　　7、变量m_keptObjects还可选择HashMap，这样更省资源