singleton 模式初识

[size=large]SINGLETON模式[/size]
[size=medium]一、 引言[/size]
想学习关系线程安全方面的，引申到singleton模式，知道这个模式，还是想系统的先弄明白.
[size=medium]二、 定义与结构[/size]
 单例类只有一个实例
 单例类必须自己创建自己的唯一的实例
 例类必须给所有其他对象提供这个唯一的实例
[size=medium]三、 实现方式[/size]
引用java与模式中的三种实现方式。

[size=medium]第一种;饿汉式单例类[/size]
[color=red]构造方法私有，避免外界利用构造方法随意的创建实例，因此这个类也不能被继承。单实例在类装载时初始化。[/color]

public class EagerSingleton {
    private EagerSingleton() { }

    public static EagerSingleton getInstance() {
        return m_instance;
    }

    /** @label Creates */
    private static final EagerSingleton m_instance = new EagerSingleton();
}

[size=medium]第二种：懒汉式单例类[/size]
[color=red]此构造方法也为私有，同样不能被继承。在类首次实例化时创建，需要处理好多个线程首次同时引用此类时的 访问限制问题。[/color]

public class LazySingleton
{
    private LazySingleton() { }

    synchronized public static LazySingleton getInstance()
    {
	    if (m_instance == null)
	    {
	        m_instance = new LazySingleton();
	    }
	    return m_instance;
	}

    /**
     * @label Creates 
     */
    private static LazySingleton m_instance = null;
}

[size=medium]第三种：登记式单例[/size]

import java.util.HashMap;

public class RegSingleton {

    protected RegSingleton() {}

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

        System.out.println("From RegSingleton: requesting for " + name );

        if (m_registry.get(name) == null)
        {
            try
            {
                m_registry.put( name, Class.forName(name).newInstance() ) ;
            }
            catch(ClassNotFoundException e)
            {
                System.out.println("Class " + name + " is not found.");
            }
            catch(InstantiationException e)
            {
                System.out.println("Class " + name + " can not be instantiated.");
            }
            catch(IllegalAccessException e)
            {
                System.out.println("Class " + name + " can not be accessed.");
            }
        }
        return  (RegSingleton) (m_registry.get(name) );
    }

    static private HashMap m_registry = new HashMap();

    /**
     * @label Creates
     * @directed*/
    /*# private RegSingletonChild lnkRegSingletonChild; */

    /**
     * @label Creates
     * @directed
     */
    /*# private RegSingleton lnkRegSingleton;  */

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

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

}

[color=red]由于构造方法非私有，子类可以继承，继承必须通过getInstance方法传入子类的类名。[/color]

import java.util.HashMap;
public class RegSingletonChild extends RegSingleton
{
    public RegSingletonChild() {}

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

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

}

[color=red]缺点是在子类产生的实例可以不在父类中登记，其次是子类的实例的产生必须是父类的实例存在才能产生[/color]


[size=medium]四、 实例[/size]
如上
属性管理器

import java.util.Properties;
import java.io.FileInputStream;
import java.io.File;

/**
* Only once instance of the class may be created during the
* execution of any given program. Instances of this class should
* be aquired through the getInstance() method. Notice that there
* are no public constructors for this class.
*/
public class ConfigManager
{
   /**
	* The private constructor (enforces single instance)
	*/
	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();
		}
	}

	/**
	* Returns the singleton ConfigManager
	*
	* @return The one and only instance of the ConfigManager
	*/
	synchronized public static ConfigManager getInstance()
	{
		return m_instance;
	}

	/**
	* Gets a configuration item
	*
	* @param name The name of the item
	* @param defaultVal The default value if name is not found
	* @return The value for the specified name
	*/
	final public Object getConfigItem(String name, Object defaultVal)
	{
		long newTime = m_file.lastModified();

		// Check to see if configuration file has been modified
		// since the previous request. If so, then read in the new
		// contents
		if(newTime == 0)
		{
			// The props file was deleted or does not exist (!!)
			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;
        }
	}

	/**
	* The fully qualified name of the properties file
	*/
	private static final String PFILE = System.getProperty("user.dir") +  "/Singleton.properties";

	/**
	* The File object corresponding to the file that contains the properties
	*/
	private File m_file = null;

	/**
	* The last modified time of the properties file
	*/
	private long m_lastModifiedTime = 0;

	/**
	* The cached properties
	*/
	private Properties m_props = null;

	/**
	* The only instance of this class
	* @label Creates
	*/
	private static ConfigManager m_instance = new ConfigManager();

[size=medium]五、 总结[/size]