研磨设计模式之单例模式-1

 

看到很多朋友在写单例，也来凑个热闹，虽然很简单，但是也有很多知识点在单例里面，看看是否能写出点不一样来。 

 

 

单例模式（Singleton）

 

1  场景问题

1.1  读取配置文件的内容

        考虑这样一个应用，读取配置文件的内容。
        很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的参数数据。当然在实际的项目中，这种配置文件多采用xml格式的。也有采用properties格式的，毕竟使用Java来读取properties格式的配置文件比较简单。
        现在要读取配置文件的内容，该如何实现呢？

1.2  不用模式的解决方案

        有些朋友会想，要读取配置文件的内容，这也不是个什么困难的事情，直接读取文件的内容，然后把文件内容存放在相应的数据对象里面就可以了。真的这么简单吗？先实现看看吧。
        为了示例简单，假设系统是采用的properties格式的配置文件。
（1）那么直接使用Java来读取配置文件，示例代码如下：

/**
 * 读取应用配置文件
 */
public class AppConfig {
	/**
	 * 用来存放配置文件中参数A的值
	 */
	private String parameterA;
	/**
	 * 用来存放配置文件中参数B的值
	 */
	private String parameterB;	

	public String getParameterA() {
		return parameterA;
	}
	public String getParameterB() {
		return parameterB;
	}
	/**
	 * 构造方法
	 */
	public AppConfig(){
		//调用读取配置文件的方法
		readConfig();
	}
	/**
	 * 读取配置文件，把配置文件中的内容读出来设置到属性上
	 */
	private void readConfig(){
		Properties p = new Properties(); 
		InputStream in = null;
		try {
			in = AppConfig.class.getResourceAsStream(
"AppConfig.properties");
			p.load(in);
			//把配置文件中的内容读出来设置到属性上
			this.parameterA = p.getProperty("paramA");
			this.parameterB = p.getProperty("paramB");
		} catch (IOException e) {
			System.out.println("装载配置文件出错了，具体堆栈信息如下：");
			e.printStackTrace();
		}finally{
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 

注意：只有访问参数的方法，没有设置参数的方法。

（2）应用的配置文件，名字是AppConfig.properties，放在AppConfig相同的包里面，简单示例如下：

paramA=a
paramB=b

 

（3）写个客户端来测试一下，示例代码如下：

public class Client {
	public static void main(String[] args) {
		//创建读取应用配置的对象
		AppConfig config = new AppConfig();
		
		String paramA = config.getParameterA();
		String paramB = config.getParameterB();
		
		System.out.println("paramA="+paramA+",paramB="+paramB);
	}
}

 

运行结果如下：

paramA=a,paramB=b

  

1.3  有何问题

        上面的实现很简单嘛，很容易的就实现了要求的功能。仔细想想，有没有什么问题呢？
        看看客户端使用这个类的地方，是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，也就是很多地方都需要创建AppConfig这个对象的实例。
        换句话说，在系统运行期间，系统中会存在很多个AppConfig的实例对象，这有什么问题吗？
        当然有问题了，试想一下，每一个AppConfig实例对象，里面都封装着配置文件的内容，系统中有多个AppConfig实例对象，也就是说系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。如果配置文件内容较少，问题还小一点，如果配置文件内容本来就多的话，对于系统资源的浪费问题就大了。事实上，对于AppConfig这种类，在运行期间，只需要一个实例对象就够了。
        把上面的描述进一步抽象一下，问题就出来了：在一个系统运行期间，某个类只需要一个类实例就可以了，那么应该怎么实现呢？

2  解决方案

2.1  单例模式来解决

        用来解决上述问题的一个合理的解决方案就是单例模式。那么什么是单例模式呢？
（1）单例模式定义
        保证一个类仅有一个实例，并提供一个访问它的全局访问点。
（2）应用单例模式来解决的思路
        仔细分析上面的问题，现在一个类能够被创建多个实例，问题的根源在于类的构造方法是公开的，也就是可以让类的外部来通过构造方法创建多个实例。换句话说，只要类的构造方法能让类的外部访问，就没有办法去控制外部来创建这个类的实例个数。
        要想控制一个类只被创建一个实例，那么首要的问题就是要把创建实例的权限收回来，让类自身来负责自己类实例的创建工作，然后由这个类来提供外部可以访问这个类实例的方法，这就是单例模式的实现方式。

2.2  模式结构和说明

单例模式结构见图1所：


 图1  单例模式结构图
Singleton：
        负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例。

2.3  单例模式示例代码

        在Java中，单例模式的实现又分为两种，一种称为懒汉式，一种称为饿汉式，其实就是在具体创建对象实例的处理上，有不同的实现方式。下面分别来看这两种实现方式的代码示例。为何这么写，具体的在后面再讲述。
       （1）懒汉式实现，示例代码如下：

/**
 * 懒汉式单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例
	 */
	private static Singleton uniqueInstance = null;
	/**
	 * 私有化构造方法，好在内部控制创建实例的数目
	 */
	private Singleton(){
		//
	}
	/**
	 * 定义一个方法来为客户端提供类实例
	 * @return 一个Singleton的实例
	 */
	public static synchronized Singleton getInstance(){
		//判断存储实例的变量是否有值
		if(uniqueInstance == null){
			//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
			uniqueInstance = new Singleton();
		}
		//如果有值，那就直接使用
		return uniqueInstance;
	}
	/**
	 * 示意方法，单例可以有自己的操作
	 */
	public void singletonOperation(){
		//功能处理
	}
	/**
	 * 示意属性，单例可以有自己的属性
	 */
	private String singletonData;
	/**
	 * 示意方法，让外部通过这些方法来访问属性的值
	 * @return 属性的值
	 */
	public String getSingletonData(){
		return singletonData;
	}
}

 

 （2）饿汉式实现，示例代码如下：

/**
 * 饿汉式单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
	 */
	private static Singleton uniqueInstance = new Singleton();
	/**
	 * 私有化构造方法，好在内部控制创建实例的数目
	 */
	private Singleton(){
		//
	}
	/**
	 * 定义一个方法来为客户端提供类实例
	 * @return 一个Singleton的实例
	 */
	public static Singleton getInstance(){
		//直接使用已经创建好的实例
		return uniqueInstance;
	}
	
	/**
	 * 示意方法，单例可以有自己的操作
	 */
	public void singletonOperation(){
		//功能处理
	}
	/**
	 * 示意属性，单例可以有自己的属性
	 */
	private String singletonData;
	/**
	 * 示意方法，让外部通过这些方法来访问属性的值
	 * @return 属性的值
	 */
	public String getSingletonData(){
		return singletonData;
	}
}

 

 

2.4  使用单例模式重写示例

        要使用单例模式来重写示例，由于单例模式有两种实现方式，这里选一种来实现就好了，就选择饿汉式的实现方式来重写示例吧。
        采用饿汉式的实现方式来重写实例的示例代码如下：

/**
 * 读取应用配置文件，单例实现
 */
public class AppConfig {
	/**
	 * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
	 */
	private static AppConfig instance = new AppConfig();
	/**
	 * 定义一个方法来为客户端提供AppConfig类的实例
	 * @return 一个AppConfig的实例
	 */
	public static AppConfig getInstance(){
		return instance;
	}
	
	/**
	 * 用来存放配置文件中参数A的值
	 */
	private String parameterA;
	/**
	 * 用来存放配置文件中参数B的值
	 */
	private String parameterB;
	public String getParameterA() {
		return parameterA;
	}
	public String getParameterB() {
		return parameterB;
	}
	/**
	 * 私有化构造方法
	 */
	private AppConfig(){
		//调用读取配置文件的方法
		readConfig();
	}
	/**
	 * 读取配置文件，把配置文件中的内容读出来设置到属性上
	 */
	private void readConfig(){
		Properties p = new Properties(); 
		InputStream in = null;
		try {
			in = AppConfig.class.getResourceAsStream(
"AppConfig.properties");
			p.load(in);
			//把配置文件中的内容读出来设置到属性上
			this.parameterA = p.getProperty("paramA");
			this.parameterB = p.getProperty("paramB");
		} catch (IOException e) {
			System.out.println("装载配置文件出错了，具体堆栈信息如下：");
			e.printStackTrace();
		}finally{
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}	
}

 

 当然，测试的客户端也需要相应的变化，示例代码如下：

public class Client {
	public static void main(String[] args) {
		//创建读取应用配置的对象
		AppConfig config = AppConfig.getInstance();

		String paramA = config.getParameterA();
		String paramB = config.getParameterB();

		System.out.println("paramA="+paramA+",paramB="+paramB);
	}
}

 

 去测试看看，是否能满足要求。

 

 

《研磨设计模式》一书已经上市，卓越网销售链接：
http://www.amazon.cn/%E7%A0%94%E7%A3%A8%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E9%99%88%E8%87%A3/dp/B004G8P90S/ref=sr_1_1?ie=UTF8&qid=1295358211&sr=8-1

 

也可以直接在卓越网上搜索《研磨设计模式》

 

当当网的销售链接：http://product.dangdang.com/product.aspx?product_id=20994349&ref=search-0-mix

 

 

希望朋友们能给本书评评分，写点评论，多谢大家的支持！

未完待续，精彩稍后继续

评论

24 楼 chengxj_1986 2011-03-29  

最近也在关注这方面的东西，感觉楼主写得不错

23 楼 ruzhefeng 2011-01-04  

没看评论的时候我就想明白饿汉懒汉名字的原因了，跟师父解释的一样 

22 楼 pktangshao 2010-09-29  

chjavach 写道

juda 写道

楼主能解释一下为什么叫饿汉，为什么叫懒汉吗

     饿汉、懒汉其实是一种比较形象的称谓。
     所谓饿汉，既然饿，那么在创建对象实例的时候就比较着急，饿了嘛，于是就在装载类的时候就创建了对象的实例，写法如下：
private static Singleton uniqueInstance = new Singleton();  

     所谓懒汉，既然是懒，那么在创建对象实例的时候就不着急，会一直等到马上要使用对象实例的时候才会创建，懒人嘛，总是推托不开的时候才去执行工作的，因此在装载对象的时候不创建对象实例，写法如下：
private static Singleton uniqueInstance = null;
等到第一次使用的时候，再创建实例，也就是在getInstance方法里面去判断和创建

学习了.

21 楼 狂放不羁 2010-09-03  

单例模式的应用场景不是很丰富，面向对象更应该讲究对象的生命周期，单例这种全局对象， 长生不老的对象，系统中还是不要太多为好。对象最重要的是职责，有职责涉及到对象的状态，有状态涉及到对象生命周期，像单例模式，以及IOC容器的那种单例，仅仅是为了无状态的技术服务而生的，其实我们应该更加关注具有生命周期，有状态的业务对象。

20 楼 Coool 2010-08-05  

不错不错，楼主写的不错。

19 楼 huihuilou 2010-08-04  

此一举了,这样
private static Singleton instance = new Singleton();不就可以

yikaicheng_happy 写道

rainsilence 写道

C的双重检查机制在java中不通用，所以饿汉式创建只能这样写。但是同步的时候会造成多线程阻塞。效率不高

既要饿汉式延迟加载，又要懒汉式效率。可以写成这样

public class Singleton {
	
	private Singleton() {
		System.out.println("Create");
	}
	
	private static class SingletonHolder {
		private static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}
	
	public static void main(String args[]) {
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
	}
}

private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
为什么要这样了多此一举了,这样
private static Singleton instance = new Singleton();不就可以了吗

If you need to use lazy initialization for performance on a static field, usethelazy initialization holder class idiom. This idiom (also known as the initialize-on-demand holder class idiom) exploits the guarantee that a class will not be ini-tialized until it is used [JLS, 12.4.1]. [effective java -item 71]

18 楼 chjavach 2010-08-02  

林海之歌 写道

配置文件 AppConfig.properties 里面的东西呢？

老兄,文章里面有,呵呵:
（2）应用的配置文件，名字是AppConfig.properties，放在AppConfig相同的包里面，简单示例如下：

paramA=a  
paramB=b 

17 楼 林海之歌 2010-07-30  

配置文件 AppConfig.properties 里面的东西呢？

16 楼 chjavach 2010-07-29  

juda 写道

多谢楼主，继续多写点东西，能出书我必买。

出了书第一个通知你,确保能卖出去一本了,哈哈!

15 楼 huihuilou 2010-07-27  

public static Singleton getInstance(){
   if(uniqueInstance == null){ 
       sychronized(Singleton.class) {
            if(uniqueInstance == null){      
                uniqueInstance = new Singleton();      
            }  
        }   
    }
     return uniqueInstance;      
    }  

14 楼 huihuilou 2010-07-27  

public static Singleton getInstance(){
   if(uniqueInstance == null){
       sychronized() {
            if(uniqueInstance == null){     
                uniqueInstance = new Singleton();     
            } 
        }  
    }
     return uniqueInstance;     
    } 

13 楼 yikaicheng_happy 2010-07-27  

rainsilence 写道

C的双重检查机制在java中不通用，所以饿汉式创建只能这样写。但是同步的时候会造成多线程阻塞。效率不高

既要饿汉式延迟加载，又要懒汉式效率。可以写成这样

public class Singleton {
	
	private Singleton() {
		System.out.println("Create");
	}
	
	private static class SingletonHolder {
		private static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}
	
	public static void main(String args[]) {
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
	}
}

private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
为什么要这样了多此一举了,这样
private static Singleton instance = new Singleton();不就可以了吗

12 楼 juda 2010-07-27  

多谢楼主，继续多写点东西，能出书我必买。

chjavach 写道

juda 写道

楼主能解释一下为什么叫饿汉，为什么叫懒汉吗

     饿汉、懒汉其实是一种比较形象的称谓。
     所谓饿汉，既然饿，那么在创建对象实例的时候就比较着急，饿了嘛，于是就在装载类的时候就创建了对象的实例，写法如下：
private static Singleton uniqueInstance = new Singleton();  

     所谓懒汉，既然是懒，那么在创建对象实例的时候就不着急，会一直等到马上要使用对象实例的时候才会创建，懒人嘛，总是推托不开的时候才去执行工作的，因此在装载对象的时候不创建对象实例，写法如下：
private static Singleton uniqueInstance = null;
等到第一次使用的时候，再创建实例，也就是在getInstance方法里面去判断和创建

11 楼 chjavach 2010-07-26  

to  8 楼的 rainsilence兄弟：
1：Java里面也是有双重检查机制的，只不过在java5以上的版本，后面会讲到

2：你写的那个实现，被称为Lazy initialization holder class模式，后面也会讲到

10 楼 chjavach 2010-07-26  

锅巴49 写道

没有考虑线程同步啊

liuyuyang 写道

线程那边控制不是最好吧。

其实是有线程控制的，虽然不够好，如6楼的bania兄弟所述

to 7楼的  liaofeng_xiao 兄弟，其实从内存分配上解释饿汉、懒汉也是可行的

9 楼 chjavach 2010-07-26  

juda 写道

楼主能解释一下为什么叫饿汉，为什么叫懒汉吗

     饿汉、懒汉其实是一种比较形象的称谓。
     所谓饿汉，既然饿，那么在创建对象实例的时候就比较着急，饿了嘛，于是就在装载类的时候就创建了对象的实例，写法如下：
private static Singleton uniqueInstance = new Singleton();  

     所谓懒汉，既然是懒，那么在创建对象实例的时候就不着急，会一直等到马上要使用对象实例的时候才会创建，懒人嘛，总是推托不开的时候才去执行工作的，因此在装载对象的时候不创建对象实例，写法如下：
private static Singleton uniqueInstance = null;
等到第一次使用的时候，再创建实例，也就是在getInstance方法里面去判断和创建

8 楼 rainsilence 2010-07-26  

C的双重检查机制在java中不通用，所以饿汉式创建只能这样写。但是同步的时候会造成多线程阻塞。效率不高

既要饿汉式延迟加载，又要懒汉式效率。可以写成这样

public class Singleton {
	
	private Singleton() {
		System.out.println("Create");
	}
	
	private static class SingletonHolder {
		private static Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}
	
	public static void main(String args[]) {
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
		System.out.println(Singleton.getInstance());
	}
}

7 楼 liaofeng_xiao 2010-07-26  

juda 写道

楼主能解释一下为什么叫饿汉，为什么叫懒汉吗

饿汉就是声明对象的同时分配内存空间：

Object obj = new Object();

懒汉是在访问对象时检测对象是否分配了内存，如果已分配便直接使用，否则进行分配内存：

public Object getObj(){
    if(obj==null){
        obj = new Object();
    }
    return obj;
}

6 楼 bania 2010-07-26  

锅巴49 写道

没有考虑线程同步啊

有考虑线程同步啊，楼主在懒汉式单例实现示例的19行：
public static synchronized Singleton getInstance(){     

不是加了synchronized 吗？

5 楼 wnick 2010-07-26  

public static synchronized Singleton getInstance(){   
        //判断存储实例的变量是否有值   
        if(uniqueInstance == null){   
            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量   
            uniqueInstance = new Singleton();   
        }   
        //如果有值，那就直接使用   
        return uniqueInstance;   
    } 

这里好像有点问题