单例模式例子java(单例模式是怎么实现的)

java 中 单实例和多实例是指的什么?

简单的说单例就是

只能有一个实例，所以地方用到的实例都是同一个。

就好像家人吃饭，桌子是单例的，大家用的是同一个。而碗是多例的，每人都有自几的。

下面是具体的例子：

Java模式之单例模式：

单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。

特点：

1，一个类只能有一个实例

2，自己创建这个实例

3，整个系统都要使用这个实例

例:

在下面的对象图中，有一个"单例对象"，而"客户甲"、"客户乙"

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

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录

数据库连接都需要这样的单线程操作。一些资源治理器经常设计成单例模式。

外部资源：譬如每台计算机可以有若干个打印机，但只能有一个Printer

Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干个通信端口，系统应当集中治理这些通信端口，以避免一个通信端口被两个请求同时调用。内部资源，譬如，大多数的软件都有一个（甚至多个）属性文件存放系统配置。这样的系统应当由一个对象来治理这些属性文件。一个例子：Windows

回收站。

在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个惟一的实例，而且回收站自行提供自己的实例。因此，回收站是单例模式的应用。

两种形式：

1，饿汉式单例类

public

class

Singleton

{

private

Singleton(){}

//在自己内部定义自己一个实例，是不是很希奇？

//注重这是private

只供内部调用

private

static

Singleton

instance

=

new

Singleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public

static

Singleton

getInstance()

{

return

instance;

}

}

2，懒汉式单例类

public

class

Singleton

{

private

static

Singleton

instance

=

null;

public

static

synchronized

Singleton

getInstance()

{

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

if

(instance==null)

instance＝new

Singleton();

return

instance;

}

}

第二中形式是lazy

initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注重到lazy

initialization形式中的synchronized，这个synchronized很重要，假如没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。

一般来说第一种比较安全。进入讨论组讨论。

Java模式设计之单例模式（二）

在什么情况下使用单例模式

使用单例模式的条件

使用单例模式有一个很重要的必要条件

在一个系统要求一个类只有一个实例时才应当使用单例模式 反过来说 如果一个类可以有几个实例共存 那么就没有必要使用单例类 但是有经验的读者可能会看到很多不当地使用单例模式的例子 可见做到上面这一点并不容易 下面就是一些这样的情况

例子一

问 我的一个系统需要一些 全程 变量 学习了单例模式后 我发现可以使用一个单例类盛放所有的 全程 变量 请问这样做对吗？

答 这样做是违背单例模式的用意的 单例模式只应当在有真正的 单一实例 的需求时才可使用

一个设计得当的系统不应当有所谓的 全程 变量 这些变量应当放到它们所描述的实体所对应的类中去 将这些变量从它们所描述的实体类中抽出来 放到一个不相干的单例类中去 会使得这些变量产生错误的依赖关系和耦合关系

例子二

问 我的一个系统需要管理与数据库的连接 学习了单例模式后 我发现可以使用一个单例类包装一个Connection 对象 并在finalize（）方法中关闭这个Connection 对象 这样的话 在这个单例类的实例没有被人引用时 这个finalize（） 对象就会被调用 因此 Connection 对象就会被释放 这多妙啊

答 这样做是不恰当的 除非有单一实例的需求 不然不要使用单例模式 在这里Connection 对象可以同时有几个实例共存 不需要是单一实例

单例模式有很多的错误使用案例都与此例子相似 它们都是试图使用单例模式管理共享资源的生命周期 这是不恰当的

单例类的状态

有状态的单例类

一个单例类可以是有状态的（stateful） 一个有状态的单例对象一般也是可变（mutable） 单例对象

有状态的可变的单例对象常常当做状态库（repositary）使用 比如一个单例对象可以持有一个int 类型的属性 用来给一个系统提供一个数值惟一的序列号码 作为某个贩卖系统的账单号码 当然 一个单例类可以持有一个聚集 从而允许存储多个状态

没有状态的单例类

另一方面 单例类也可以是没有状态的（stateless） 仅用做提供工具性函数的对象 既然是为了提供工具性函数 也就没有必要创建多个实例 因此使用单例模式很合适 一个没有状态的单例类也就是不变（Immutable） 单例类 关于不变模式 读者可以参见本书的 不变（Immutable ）模式 一章

多个JVM 系统的分散式系统

EJB 容器有能力将一个EJB 的实例跨过几个JVM 调用 由于单例对象不是EJB 因此 单例类局限于某一个JVM 中 换言之 如果EJB 在跨过JVM 后仍然需要引用同一个单例类的话 这个单例类就会在数个JVM 中被实例化 造成多个单例对象的实例出现 一个J EE应用系统可能分布在数个JVM 中 这时候不一定需要EJB 就能造成多个单例类的实例出现在不同JVM 中的情况

如果这个单例类是没有状态的 那么就没有问题 因为没有状态的对象是没有区别的 但是如果这个单例类是有状态的 那么问题就来了 举例来说 如果一个单例对象可以持有一个int 类型的属性 用来给一个系统提供一个数值惟一的序列号码 作为某个贩卖系统的账单号码的话 用户会看到同一个号码出现好几次

在任何使用了EJB RMI 和JINI 技术的分散式系统中 应当避免使用有状态的单例模式

多个类加载器

同一个JVM 中会有多个类加载器 当两个类加载器同时加载同一个类时 会出现两个实例 在很多J EE 服务器允许同一个服务器内有几个Servlet 引擎时 每一个引擎都有独立的类加载器 经有不同的类加载器加载的对象之间是绝缘的

lishixinzhi/Article/program/Java/gj/201311/27644

Java模式设计之单例模式（一）

作为对象的创建模式[GOF ] 单例模式确保某一个类只有一个实例 而且自行实例化并向整个系统提供这个实例 这个类称为单例类

单例模式的要点

单例单例

显然单例模式的要点有三个 一是某各类只能有一个实例 二是它必须自行创建这个事例 三是它必须自行向整个系统提供这个实例 在下面的对象图中 有一个 单例对象 而 客户甲 客户乙 和 客户丙 是单例对象的三个客户对象 可以看到 所有的客户对象共享一个单例对象 而且从单例对象到自身的连接线可以看出 单例对象持有对自己的引用

资源管理

一些资源管理器常常设计成单例模式

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

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

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

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

一个例子 Windows 回收站

Windows x 以后的视窗系统中都有一个回收站 下图就显示了Windows 的回收站

在整个视窗系统中 回收站只能有一个实例 整个系统都使用这个惟一的实例 而且回收站自行提供自己的实例 因此 回收站是单例模式的应用

双重检查成例

在本章最后的附录里研究了双重检查成例 双重检查成例与单例模式并无直接的关系 但是由于很多C 语言设计师在单例模式里面使用双重检查成例 所以这一做法也被很多Java 设计师所模仿 因此 本书在附录里提醒读者 双重检查成例在Java 语言里并不能成立 详情请见本章的附录

单例模式的结构

单例模式有以下的特点

…… 单例类只可有一个实例

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

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

虽然单例模式中的单例类被限定只能有一个实例 但是单例模式和单例类可以很容易被推广到任意且有限多个实例的情况 这时候称它为多例模式（Multiton Pattern） 和多例类（Multiton Class） 请见 专题 多例（Multiton ）模式与多语言支持 一章 单例类的简略类图如下所示

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

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

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

代码清单 饿汉式单例类

public class EagerSingleton { private static final EagerSingleton m_instance = new EagerSingleton（） /** * 私有的默认构造子*/ private EagerSingleton（） { } /** * 静态工厂方法*/ public static EagerSingleton getInstance（）

{

Java 与模式return m_instance }

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

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

懒汉式单例类

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

代码清单 懒汉式单例类

package 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 语言中使用 不十分熟悉的读者 可以看看后面给出的小节

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

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

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

登记式单例类

登记式单例类是GoF 为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的 本书把他们的例子翻译为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 = 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（ javapatterns singleton demos RegSingletonChild ） } /** * 一个示意性的商业方法*/ public String about（）

{ return Hello I am RegSingletonChild }

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

lishixinzhi/Article/program/Java/gj/201311/27416

java中的单例模式的代码怎么写

我从我的博客里把我的文章粘贴过来吧，对于单例模式模式应该有比较清楚的解释：

单例模式在我们日常的项目中十分常见，当我们在项目中需要一个这样的一个对象，这个对象在内存中只能有一个实例，这时我们就需要用到单例。

一般说来，单例模式通常有以下几种：

1.饥汉式单例

public class Singleton {

private Singleton(){};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

}

这是最简单的单例，这种单例最常见，也很可靠！它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时，单例就会被加载到内存中。

在这里我们可以做个这样的测试：

将上述代码修改为：

public class Singleton {

private Singleton(){

System.out.println("createSingleton");

};

private static Singleton instance = new Singleton();

public static Singleton getInstance(){

return instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

而我们在另外一个测试类中对它进行测试（本例所有测试都通过Junit进行测试）

public class TestSingleton {

@Test

public void test(){

Singleton.testSingleton();

}

}

输出结果：

createSingleton

CreateString

我们可以注意到，在这个单例中，即使我们没有使用单例类，它还是被创建出来了，这当然是我们所不愿意看到的，所以也就有了以下一种单例。

2.懒汉式单例

public class Singleton1 {

private Singleton1(){

System.out.println("createSingleton");

}

private static Singleton1 instance = null;

public static synchronized Singleton1 getInstance(){

return instance==null?new Singleton1():instance;

}

public static void testSingleton(){

System.out.println("CreateString");

}

}

上面的单例获取实例时，是需要加上同步的，如果不加上同步，在多线程的环境中，当线程1完成新建单例操作，而在完成赋值操作之前，线程2就可能判

断instance为空，此时，线程2也将启动新建单例的操作，那么多个就出现了多个实例被新建，也就违反了我们使用单例模式的初衷了。

我们在这里也通过一个测试类，对它进行测试，最后面输出是

CreateString

可以看出，在未使用到单例类时，单例类并不会加载到内存中，只有我们需要使用到他的时候，才会进行实例化。

这种单例解决了单例的延迟加载，但是由于引入了同步的关键字，因此在多线程的环境下，所需的消耗的时间要远远大于第一种单例。我们可以通过一段测试代码来说明这个问题。

public class TestSingleton {

@Test

public void test(){

long beginTime1 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton.getInstance();

}

System.out.println("单例1花费时间："+(System.currentTimeMillis()-beginTime1));

long beginTime2 = System.currentTimeMillis();

for(int i=0;i100000;i++){

Singleton1.getInstance();

}

System.out.println("单例2花费时间："+(System.currentTimeMillis()-beginTime2));

}

}

最后输出的是：

单例1花费时间：0

单例2花费时间：10

可以看到，使用第一种单例耗时0ms，第二种单例耗时10ms，性能上存在明显的差异。为了使用延迟加载的功能，而导致单例的性能上存在明显差异，

是不是会得不偿失呢？是否可以找到一种更好的解决的办法呢？既可以解决延迟加载，又不至于性能损耗过多，所以，也就有了第三种单例：

3.内部类托管单例

public class Singleton2 {

private Singleton2(){}

private static class SingletonHolder{

private static Singleton2 instance=new Singleton2();

}

private static Singleton2 getInstance(){

return SingletonHolder.instance;

}

}

在这个单例中，我们通过静态内部类来托管单例，当这个单例被加载时，不会初始化单例类，只有当getInstance方法被调用的时候，才会去加载

SingletonHolder，从而才会去初始化instance。并且，单例的加载是在内部类的加载的时候完成的，所以天生对线程友好，而且也不需要

synchnoized关键字，可以说是兼具了以上的两个优点。

4.总结

一般来说，上述的单例已经基本可以保证在一个系统中只会存在一个实例了，但是，仍然可能会有其他的情况，导致系统生成多个单例，请看以下情况：

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

}

通过一段代码来测试：

@Test

public void test() throws Exception{

Singleton3 s1 = null;

Singleton3 s2 = Singleton3.getInstance();

//1.将实例串行话到文件

FileOutputStream fos = new FileOutputStream("singleton.txt");

ObjectOutputStream oos =new ObjectOutputStream(fos);

oos.writeObject(s2);

oos.flush();

oos.close();

//2.从文件中读取出单例

FileInputStream fis = new FileInputStream("singleton.txt");

ObjectInputStream ois = new ObjectInputStream(fis);

s1 = (Singleton3) ois.readObject();

if(s1==s2){

System.out.println("同一个实例");

}else{

System.out.println("不是同一个实例");

}

}

输出：

不是同一个实例

可以看到当我们把单例反序列化后，生成了多个不同的单例类，此时，我们必须在原来的代码中加入readResolve()函数，来阻止它生成新的单例

public class Singleton3 implements Serializable{

private Singleton3(){}

private static class SingletonHolder{

private static Singleton3 instance = new Singleton3();

}

public static Singleton3 getInstance(){

return SingletonHolder.instance;

}

//阻止生成新的实例

public Object readResolve(){

return SingletonHolder.instance;

}

}

再次测试时，就可以发现他们生成的是同一个实例了。

JAVA单例模式的几种实现方法

JAVA

单例模式的几种实现方法

1.饿汉式单例类

package

pattern.singleton;

//

饿汉式单例类

.

在类初始化时，已经自行实例化

public

class

Singleton1

{

//

私有的默认构造子

private

Singleton1()

{}

//

已经自行实例化

private

static

final

Singleton1

single

=

new

Singleton1();

//

静态工厂方法

public

static

Singleton1

getInstance()

{

return

single;

}

}

2.

懒汉式单例类

package

pattern.singleton;

//

懒汉式单例类

.

在第一次调用的时候实例化

public

class

Singleton2

{

//

私有的默认构造子

private

Singleton2()

{}

//

注意，这里没有

final

private

static

Singleton2

single;

//

只实例化一次

static

{

single

=

new

Singleton2();

}

//

静态工厂方法

public

synchronized

static

Singleton2

getInstance()

{

if

(single

==

null

)

{

single

=

new

Singleton2();

}

return

single;

}

}

在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，以处理多线程环境。有些设计师在这里建议使用所谓的

"

双重检查成例

".

必须指出的是，

"

双重检查成例

"

不可以在

Java

语言中使用。不十分熟悉的读者，可以看看后面给出的小节。

同

样，由于构造子是私有的，因此，此类不能被继承。饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的，在饿汉

式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲，

则

比懒汉式单例类稍好些。然而，懒汉式单例类在实例化时，必须处

理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源

初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的机率变得较大。

饿汉式单例类可以在

Java

语言内实现，

但不易在

C++

内实现，因为静态初始化在

C++

里没有固定的顺序，因而静态的

m_instance

变量的初始化与类的加载顺序没有保证，可能会出问题。这就是为什么

GoF

在提出单例类的概念时，举的例子是懒

汉式的。他们的书影响之大，以致

Java

语言中单例类的例子也大多是懒汉式的。实际上，本书认为饿汉式单例类更符合

Java

语

言本身的特点。

3.

登记式单例类

.

package

pattern.singleton;

import

java.util.HashMap;

import

java.util.Map;

//

登记式单例类

.

//

类似

Spring

里面的方法，将类名注册，下次从里面直接获取。

public

class

Singleton3

{

private

static

MapString,Singleton3

map

=

new

HashMapString,Singleton3();

static

{

Singleton3

single

=

new

Singleton3();

map.put(single.getClass().getName(),

single);

}

//

保护的默认构造子

protected

Singleton3(){}

//

静态工厂方法

,

返还此类惟一的实例

public

static

Singleton3

getInstance(String

name)

{

if

(name

==

null

)

{

name

=

Singleton3.

class

.getName();

System.out.println("name

==

null"+"---name="+name);

}

if

(map.get(name)

==

null

)

{

try

{

map.put(name,

(Singleton3)

Class.forName(name).newInstance());

}

catch

(InstantiationException

e)

{

e.printStackTrace();

}

catch

(IllegalAccessException

e)

{

e.printStackTrace();

}

catch

(ClassNotFoundException

e)

{

e.printStackTrace();

}

}

return

map.get(name);

}

//

一个示意性的商业方法

public

String

about()

{

return

"Hello,

I

am

RegSingleton.";

}

public

static

void

main(String[]

args)

{

Singleton3

single3

=

Singleton3.getInstance(

null

);

System.out.println(single3.about());

}

}

JAVA单例模式有哪些？

一、懒汉式单例

在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

public class LazySingleton {

/**

* 私有静态对象,加载时候不做初始化

*/

private static LazySingleton m_intance=null;

/**

* 私有构造方法,避免外部创建实例

*/

private LazySingleton(){

}

/**

* 静态工厂方法,返回此类的唯一实例.

* 当发现实例没有初始化的时候,才初始化.

*/

synchronized public static LazySingleton getInstance(){

if(m_intance==null){

m_intance=new LazySingleton();

}

return m_intance;

}

}

二、饿汉式单例

在类被加载的时候，唯一实例已经被创建。

public class EagerSingleton {

/**

* 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象

*/

private static final EagerSingleton m_instance = new EagerSingleton();

/**

* 私有构造方法,避免外部创建实例

*/

private EagerSingleton() {

}

/**

* 静态工厂方法,返回此类的唯一实例.

* @return EagerSingleton

*/

public static EagerSingleton getInstance() {

return m_instance;

}

}

************************************************************************************** 懒汉方式，指全局的单例实例在第一次被使用时构建；

饿汉方式，指全局的单例实例在类装载时构建

**************************************************************************************

三、登记式单例

这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

public class RegSingleton {

/**

* 登记薄,用来存放所有登记的实例

*/

private static MapString, RegSingleton m_registry = new HashMap();

//在类加载的时候添加一个实例到登记薄

static {

RegSingleton x = new RegSingleton();

m_registry.put(x.getClass().getName(), x);

}

/**

* 受保护的默认构造方法

*/

protected RegSingleton() {

}

/**

* 静态工厂方法,返回指定登记对象的唯一实例;

* 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回

* @param name

* @return RegSingleton

*/

public static RegSingleton getInstance(String name) {

if (name == null) {

name = "RegSingleton";

}

if (m_registry.get(name) == null) {

try {

m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

return m_registry.get(name);

}

/**

* 一个示意性的商业方法

* @return String

*/

public String about() {

return "Hello,I am RegSingleton!";

}

}