java单例类的代码

/**
 * 饿汉式单实例
 */
public class SingleExample ...{

    // 测试
    public static void main(String[] args) ...{
        SingleExampleClass sec = SingleExampleClass.getInstance();
        SingleExampleClass sec2 = SingleExampleClass.getInstance();
       
        if (sec == sec2) System.out.println(sec + " " + sec2);
    }

}

/** *//**
 * 单实例类
 */
class SingleExampleClass ...{
    private static SingleExampleClass sec = new SingleExampleClass();
   
    private SingleExampleClass() ...{
    }
   
    public static SingleExampleClass getInstance() ...{
        return sec;
    }
}

 

///懒汉式

 

 

package com.javapatterns.singleton.demos；

public class LazySingleton {

 private static LazySingleton m_instance = null；

/** * 私有的默认构造子，保证外界无法直接实例化*/

 private LazySingleton（） {

 }

 /** * 静态工厂方法，返还此类的惟一实例*/

 synchronized public static LazySingleton getInstance（）

　　{ if （m_instance == null）

　　      { m_instance = new LazySingleton（）；}

         return m_instance；}

 

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

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

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

 

/登记式单例类

 

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（） {} /** * 静态工厂方法，返还此类惟一的实例*/ 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） ）；} /** * 一个示意性的商业方法*/ public String about（）

　　{ return "Hello， I am RegSingleton."；}它的子类RegSingletonChild 需要父类的帮助才能实例化。

 

登记式单例类的子类

 

 

　　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."；}

　　在GoF 原始的例子中，并没有getInstance（） 方法，这样得到子类必须调用的getInstance（String name）方法并传入子类的名字，因此很不方便。本章在登记式单例类子类的例子里，加入了getInstance（） 方法，这样做的好处是RegSingletonChild 可以通过这个方法，返还自已的实例。而这样做的缺点是，由于数据类型不同，无法在RegSingleton 提供这样一个方法。由于子类必须允许父类以构造子调用产生实例，因此，它的构造子必须是公开的。这样一来，就等于允许了以这样方式产生实例而不在父类的登记中。这是登记式单例类的一个缺点。

　　GoF 曾指出，由于父类的实例必须存在才可能有子类的实例，这在有些情况下是一个浪费。这是登记式单例类的另一个缺点。