二十四：单例模式

Java中的单例模式是指在程序的运行过程中,jvm中只存在一个实例。然而注意，Spring中配置的singleton是相对于IOC的工厂而言，一个IOC工厂里只有一个实例，然而在jvm中可能有多个实例，他们的参照物不同.


一：单例类有如下特点
A:只能有一个实例
B:必须自己创建自己的唯一实例
C:必须向系统提供自己的实例

二：饿汉式单例类

package cai.milenfan.basic.test; 

public class EagerSingleton { 
private static final EagerSingleton eagerSingleton = new EagerSingleton(); 
private EagerSingleton(){} 
public static EagerSingleton getInstance(){ 
return eagerSingleton; 
} 
} 

从上面的代码可以看出，饿汉式单例类在类被加载地，静态变量eagerSingleton会被初始化，此时类的私有构造子会被调用，这时单例类的唯一实例就被创建出来。 Java语言中单例类的一个重要特点就是构造子是私有的，从而避免外界利用构造子直接创建出多个实例，值得指出的是，由于构造子是私有的，因此此类不能被继承.

三：懒汉式单例类

package cai.milenfan.basic.test; 

public class LazySingleton { 
private static LazySingleton lazySingleton = null; 
private LazySingleton(){} 
synchronized public static LazySingleton getInstance(){ 
if(lazySingleton==null){ 
lazySingleton = new LazySingleton(); 
} 
return lazySingleton; 
} 
} 

在上面的懒汉式单例类里对静态工厂方法使用了同步，以处理多线程环境中多个线程同时首次引用此类时访问限制问题(有些设计师在这里建议使用所谓的"双重检查成例"，应当指出在Java中不可以使用)

四：登记式单例类
登记式单例类是为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的，请看下面的源码：

package cai.milenfan.basic.test; 

import java.util.HashMap; 

public class RegSingleton { 
static private HashMap regMap = new HashMap(); 
static{ 
RegSingleton x = new RegSingleton(); 
regMap.put(x.getClass().getName(),x); 
} 
protected RegSingleton(){} 

static public RegSingleton getInstance(String name){ 
if(name==null){ 
name="cai.milenfan.basic.test.RegSingleton"; 
} 
if(regMap.get(name)==null){ 
try { 
regMap.put(name,Class.forName(name).newInstance());
} catch (Exception e) {} 
} 
return (RegSingleton)regMap.get(name); 
} 
} 

它的子类如下，需要父类的帮助才能实例化:

package cai.milenfan.basic.test; 

public class RegSingletonChild extends RegSingleton{ 
public RegSingletonChild(){} 
static public RegSingletonChild getInstance(){ 
return (RegSingletonChild)RegSingleton.getInstance("cai.milenfan.basic.test.RegSingletonChild");
} 
} 

由于子类必须允许父类以构造子调用产生实例，因此子类的构造子必须是公开的.

五：一个实用的例子--属性管理器
大多数的系统都有一些配置常量，这些常量如果是存储在程序内部，那么每次个性这些常量都需要编译程序，将这些常量放在配置文件中，系统通过访问这个配置文件取得配置常量，就可以通过修改这个配置文件无需修改程序而达到更改系统配置的目的,下面将设计一个属性管理器类ConfigManager:

package cai.milenfan.basic.test; 

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

public class ConfigManager { 
//属性文件全名 
private static final String P_FILE = System.getProperty("user.dir") + File.separator + "singleton.properties"; 
//对应于属性文件的变量 
private File mFile = null; 
//最后修改时间 
private long lastModifyTime = 0; 
//属性文件所对应的属性对象的变量 
private Properties mProps = null; 
//唯一的实例 
private static ConfigManager instance = new ConfigManager(); 

private ConfigManager(){ 
mFile = new File(P_FILE); 
lastModifyTime = mFile.lastModified(); 
if(lastModifyTime==0){ 
System.out.println(P_FILE + " does not exit........"); 
} 
mProps = new Properties(); 
try { 
mProps.load(new FileInputStream(P_FILE)); 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
//静态工厂方法，返回唯一实例 
synchronized public static ConfigManager getInstance(){ 
return instance; 
} 

//读取一个特定的属性 
final public Object getConfigItem(String key,Object value){ 
long newTime = mFile.lastModified(); 
if(newTime==0){ 
if(lastModifyTime==0){ 
System.out.println(P_FILE + " does not exit........"); 
}else{ 
System.out.println(P_FILE + " was deleted.........."); 
} 
return value; 
}else if(newTime>lastModifyTime){ 
mProps.clear(); 
try { 
mProps.load(new FileInputStream(P_FILE)); 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
lastModifyTime = newTime; 
Object newvalue = mProps.get(key); 
if(newvalue==null){ 
return value; 
}else{ 
return newvalue; 
} 
} 
} 
singleton.properties是一个键值对应的文件： 
item1=how 
item2=are 
item3=you 

为什么这个类要使用单例模式：因为属性是系统的一种"资源"，应当避免有多于一个的对象读取，特别是存储属性,此外，属性的读取可能会在很多地方发生，创建属性对象的地方应当放在哪里不是很清楚，换言之，属性管理器应当自己创建自己的实例，并且自己向系统全程提供这个实例，因此属性文件管理器ConfigManager应当是由一个单例进行负责的。
这个管理器类还有一个有意思的功能，即在每一次调用时，会检查属性文件是否被更新过，如果确实被更新过的话，管理器会自动重新加载属性文件，从而保证管理器的内容与属性文件的内容总是一致的.

六：Java语言中运用单例模式的例子
A:java.lang.Runtime
在每一个java应用程序里面，都有唯一一个Runtime对象，通过这个对象，应用程序可以与其运行环境发生相互作用，如执行外部命令(打开一个记事本)，返回现在内存，运行垃圾收集器，加载动态库等等。
B:java.util.Introspector类
Sun提供了一个BeanBox系统，允许动态地加载JavaBean,并动态修改其性质.在这个系统中只需要一个Introspector对象，因此它被设计成单例..
C:java.awt.Toolkit
此类的getDefaultToolkit()提供唯一的实例，这个方法相当于懒汉式的单例方法，因此整个方法都是同步的.由于Toolkit是一个抽象类，因此如果其子类提供一个私有的构造子，那么其子类便是一个正常的单例类，而如果其子类作为具体实现提供一个公开的构造子，这时候这个具体子类便是"不完全"的单例类.
(注：getDefaultToolkit()方法实际上是一个模板方法，私有构造子是推迟到子类实现的剩余逻辑，根据子类对这个剩余逻辑的不同实现，子类就可以提供完全不同的行为.)
D:javax.swing.TimerQueue
这是一个不完全的单例类，再作介绍。