单例模式简介(Java)

       引用《JAVA与模式》第10章

       单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

　　单例模式要点

　　单例模式的要点有三个：

             一、是某各类只能有一个实例；

             二、是它必须自行创建这个事例；

             三、是它必须自行向整个系统提供这个实例。

      在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙" 和"客户丙"是单例对象的三个客户对象。可以看到，所有的客户对象共享一个单例对象。而且从单例对象到自身的连接线可以看出，单例对象持有对自己的引用。



　　资源管理

　　一些资源管理器（数据库连接器）常常设计成单例模式。

　　在计算机系统中，需要管理的资源包括软件外部资源，譬如每台计算机可以有若干个打印机，但只能有一个Printer Spooler， 以避免两个打印作业同时输出到打印机中。每台计算机可以有若干传真卡，但是只应该有一个软件负责管理传真卡，以避免出现两份传真作业同时传到传真卡中的情况。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。

　　需要管理的资源包括软件内部资源，譬如，大多数的软件都有一个（甚至多个）属性（properties）文件存放系统配置。这样的系统应当由一个对象来管理一个属性文件。

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

　　这些资源管理器构件必须只有一个实例，这是其一；它们必须自行初始化，这是其二；允许整个系统访问自己这是其三。因此，它们都满足单例模式的条件，是单例模式的应用。

单例模式的结构

　　单例模式有以下的特点：

　　　.. 单例类只可有一个实例。

　　　.. 单例类必须自己创建自己这惟一的实例。

　　　.. 单例类必须给所有其他对象提供这一实例。

　　虽然单例模式中的单例类被限定只能有一个实例，但是单例模式和单例类可以很容易被推广到任意且有限多个实例的情况，这时候称它为多例模式（Multiton Pattern） 和多例类（Multiton Class)。


　　由于Java 语言的特点，使得单例模式在Java 语言的实现上有自己的特点。这些特点主要表现在单例类如何将自己实例化上。

饿汉式单例
　　饿汉式单例类饿汉式单例类是在Java 语言里实现得最为简便的单例类，下面所示的类图描述了一个饿汉式单例类的典型实现。

　　从图中可以看出，此类已经自已将自己实例化。

　　代码清单1：饿汉式单例类

public class EagerSingleton 
{ 
    private static final EagerSingleton m_instance = new EagerSingleton(); 

   /** 
   * 私有的默认构造方法 
   */ 
   private EagerSingleton() { } 

   /** 
   * 静态方法获得单例 
   */ 
   public static EagerSingleton getInstance() 
   {
      return m_instance; 
   }
} 

　　读者可以看出，在这个类被加载时，静态变量m_instance 会被初始化，此时类的私有构造子会被调用。这时候，单例类的惟一实例就被创建出来了。

　　Java 语言中单例类的一个最重要的特点是类的构造子是私有的，从而避免外界利用构造子直接创建出任意多的实例。值得指出的是，由于构造子是私有的，因此，此类不能被继承。

　　懒汉式单例类

　　与饿汉式单例类相同之处是，类的构造子是私有的。与饿汉式单例类不同的是，懒汉式单例类在第一次被引用时将自己实例化。如果加载器是静态的，那么在懒汉式单例类被加载时不会将自己实例化。如下图所示，类图中给出了一个典型的饿汉式单例类实现。



　　代码清单2：懒汉式单例类

package com.javapatterns.singleton.demos;
public class LazySingleton
{
    private static LazySingleton m_instance = null;

    /**
    * 私有的默认构造方法，保证外界无法直接实例化
    */
    private LazySingleton() { }

    /**
    * 静态方法，返还此类的惟一实例
    */
    public synchronized static LazySingleton getInstance()
    {
        if (m_instance == null)
        {
            m_instance = new LazySingleton();
        }
        return m_instance;
    }
}

 

　　同样，由于构造方法是私有的，因此，此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。

　　从速度和反应时间角度来讲，则比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时， 必须处理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。

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

　　登记式单例类

　　登记式单例类是为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的。如下图所示是登记式单例类的一个例子，图中的关系线表明，此类已将自己实例化。



　　代码清单3：登记式单例类

import java.util.HashMap;
public class RegSingleton
{
    static private HashMap m_registry = new HashMap();

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

    /**
    * 保护的默认构造方法
    */
    protected RegSingleton() {}

    /**
    * 静态方法，返还此类惟一的实例
    */
    public static 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) );
    }
}
　　它的子类RegSingletonChild 需要父类的帮助才能实例化。下图所示是登记式单例类子类的一个例子。图中的关系表明，此类是由父类将子类实例化的。



　　下面是子类的源代码。

　　代码清单4：登记式单例类的子类

    /**
    * 静态工厂方法
    */
    public static RegSingletonChild getInstance()
    {
        return (RegSingletonChild)
        RegSingleton.getInstance("com.javapatterns.singleton.demos.RegSingletonChild" );
    }

} 

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

 

　　在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。