单例设计模式

设计模式

即解决某类问题的最优方案，强调解决问题的思想。

某种问题有各种解决的办法，从中选取最好的一种办法，最为以后处理问题的统一处理方式，该办法就成为一种模式！

 

 

单例设计模式

解决的问题：

确保一个类在内存中只有唯一的对象；

步骤：

构造方法私有化，保证外界无法创建对象

本类创建自己的对象，并对外提供获取该唯一对象的“接口”

外界通过这个接口获取返回的对象的引用

 

饿汉式（推荐开发中使用）

类一加载就在堆内存创建对象，在外界获取之前就创建好。

package com.gc.design.single;


public class SingleHungry {
	
	//保证成员属性可控，私有化
	private static SingleHungry instance = new SingleHungry();
	
	//禁止外界创建对象
	private SingleHungry() {
		
	}
	
	//由于外界没有对象来调用本类方法，所以方法静态化
	//返回内存中唯一的对象给调用者
	public static SingleHungry getInstance(String code) {
		//通过参数来判断是否返回实例给调用者
		if(code.equals("xxx"))
			return instance;
		return null;
	}
	
}

 

懒汉式

真正获取对象实例的时候，才创建对象

特别注意：为了保证多线程并发时对象的唯一性，需要加synchronized修饰方法。

 

package com.gc.design.single;

public class SingleLazy {
	//初始时不创建对象
	private static SingleLazy instance = null;
	
	//禁止外界创建对象
	private SingleLazy() {
		
	}
	
	//synchronized---多线程并发时，保证对象的唯一性
	public static synchronized SingleLazy getInstance() {
		//真正需要的时候才创建对象
		if(instance == null)
			instance = new SingleLazy();
		return instance;
	}
	
}

  

改进懒汉式，改变加锁的位置

package com.gc.design.single;

public class SingleLazy2 {
	//初始时不创建对象
	private static SingleLazy2 instance = null;
	
	//禁止外界创建对象
	private SingleLazy2() {
		
	}
	
	//synchronized---锁加在方法上，效率低，每次进入方法都需要判断锁
	public static SingleLazy2 getInstance() {
		if(instance==null) {
			//静态函数中，没有this锁，只能使用类的class对象
			synchronized(SingleLazy2.class) {
				//真正需要的时候才创建对象
				if(instance == null)
					instance = new SingleLazy2();
			}
		}
		return instance;
	}
	
}

 

 

 

========================================================================

 

单例模式的实际应用

---读取配置文件

资源文件，如189.properties被放在 xxx/WEB-INF/classes目录下

本示例程序涉及以下几方面的知识：

1.单例模式的应用

2.属性文件的加载

3.文件和流的操作

4.多线程下同步问题的考虑

 

注意：

未针对发生修改的文件进行单独加载，而是一旦有文件发生修改，就重新加载所有的配置，以后改进。程序健壮性有待提高，考虑的点不全，需要改进。没有时间了，暂时先这样。

代码如下:

package com.gc.sms.util;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ConfigManager {
	
	//是否动态加载properties文件
	//动态加载虽然好，但是影响效率，每次都要比较文件修改时间
	private boolean autoReload = false;
	
	private final String BASE_PATH = "/";
	
	private Properties props = null;
	
	private Map<String,Long> lastModifiedMap = new HashMap<String, Long>();

	private static ConfigManager instance = new ConfigManager();
	
	private ConfigManager() {
		props = new Properties();
		init();
	}
	
	public static ConfigManager getInstance() {
		return instance;
	}


	private void init() {
		InputStream[] ins = getAllPropertiesInputStream();
		for (int i = 0; i < ins.length; i++) {
			try {
				props.load(ins[i]);
			} catch (IOException e) {
				throw new RuntimeException("加载配置文件出现异常",e);
			} finally {
				try {
					ins[i].close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	private void init(File[] files) {
		props.clear();
		InputStream[] ins = getInputStreamsFromFiles(files);
		for (int i = 0; i < ins.length; i++) {
			try {
				props.load(ins[i]);
			} catch (IOException e) {
				throw new RuntimeException("加载配置文件出现异常",e);
			} finally {
				try {
					ins[i].close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	private InputStream[] getAllPropertiesInputStream() {
		File[] files = getAllPropertiesFiles();
		InputStream[] ins = getInputStreamsFromFiles(files);
		return ins;
	}

	private InputStream[] getInputStreamsFromFiles(File[] files) {
		InputStream[] ins = new InputStream[files.length];
		for (int i = 0; i < files.length; i++) {
			File file = files[i];
			String fileName = file.getName();
			//第1次加载和之后重新加载，这里都对文件的最后修改时间进行了保存。
			if(autoReload)
				lastModifiedMap.put(fileName, Long.valueOf(file.lastModified()));
			ins[i] = ClassLoader.getSystemResourceAsStream(fileName);
		}
		return ins;
	}

	private File[] getAllPropertiesFiles() {
		String parentPath = Class.class.getResource(BASE_PATH).getPath();
		File parentFile = new File(parentPath);
		File[] files = parentFile.listFiles(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				return name.endsWith(".properties");
			}
		});
		return files;
	}

	public String getConfigItem(String key) {
		if(autoReload) {
			accordingModifiedTimeDecideReload();
		}
		return props.getProperty(key);
	}

	
	public Map<String,String> getAllConfigItem() {
		if(autoReload) {
			accordingModifiedTimeDecideReload();
		}
		Enumeration<?> enums = props.propertyNames();
		Map<String,String> confs = new HashMap<String,String>();
		while(enums.hasMoreElements()) {
			String key = (String)enums.nextElement();
			confs.put(key, (String) props.get(key));
		}
		return confs;
	}
	
	//多线程并发时，如果有一个文件发生修改，则重新加载所有的配置，需要同步
	private synchronized void accordingModifiedTimeDecideReload() {
		File[] files = getAllPropertiesFiles();
		for (File file : files) {
			if(lastModifiedMap.get(file.getName())!=null &&
					file.lastModified() > lastModifiedMap.get(file.getName())) {
				init(files);
				break;
			}
		}
	}
	

}

 

main()创建多线程环境进行测试

	//测试，线程睡眠的时候，修改配置文件中的数据，线程醒过来后应该读取到新的配置
	//前提是autoReload = true
	public static void main(String[] args) {

		for(int i=0;i<100;i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					try {
						int time = 1000+new Random().nextInt(100000);
						System.out.println(Thread.currentThread().getName()+":sleep\t"+time/1000);
						Thread.currentThread().sleep(time);
					} catch (InterruptedException e) {e.printStackTrace();}
					ConfigManager instance = ConfigManager.getInstance();
					String value = instance.getConfigItem("ip");
					System.out.println(value);
				}
			}).start();
		}
	}