一 定义
保证一个类只有仅有一个实例,并提供一个访问它的全局访问点。
二 案例
一个很简单的案例,读取配置文件,这里读取properties文件。
三 未使用模式的情况
很容易写出如下代码:
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
*
* Created by jerry on 16-4-12.
*/
public class AppConfig {
private String parameterA;
private String parameterB;
public AppConfig() {
readConfig();
}
private void readConfig() {
Properties prop = new Properties();
InputStream in = null;
try {
in = AppConfig.class.getResourceAsStream("AppConfig.properties");
prop.load(in);
this.parameterA = prop.getProperty("paraA");
this.parameterB = prop.getProperty("paraB");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String getParameterA() {
return parameterA;
}
public String getParameterB() {
return parameterB;
}
}
/**
* Created by jerry on 16-4-12.
*/
public class Client {
public static void main(String[] args) {
AppConfig config = new AppConfig();
String paraA = config.getParameterA();
String paraB = config.getParameterB();
System.out.println(paraA);
System.out.println(paraB);
}
}
# 配置文件 AppConfig.properties
paraA = a
paraB = b
试想:如果我在整个项目中有多处地方需要用到AppConfig 对象,不断的new会使得内存中存在多个实例。如果配置文件很小,那么影响不会很大,但是如果配置文件中内容特别多的话,那么将会占据很多资源。而事实上,AppConfig功能仅仅是读取配置文件而已,只需要一个实例对象就够了。
四 使用模式的情况
单例模式的写法很简单。只需分为3个步骤:
- 将构造函数私有化
- 创建一个类的实例的静态变量
- 提供一个返回类实例的静态方法
单例模式又分为
懒汉式 和 饿汉式。下面一一介绍。
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 懒汉式
* Created by jerry on 16-4-12.
*/
public class AppConfig_Lazy {
private String parameterA;
private String parameterB;
private static AppConfig_Lazy instance = null;
public static AppConfig_Lazy getInstance() {
//首先判断实例有没有初始化
if (instance == null){
//如果没有初始化那么new一个实例
instance = new AppConfig_Lazy();
}
return instance;
}
private AppConfig_Lazy() {
readConfig();
}
private void readConfig() {
Properties prop = new Properties();
InputStream in = null;
try {
in = AppConfig_Lazy.class.getResourceAsStream("AppConfig.properties");
prop.load(in);
this.parameterA = prop.getProperty("paraA");
this.parameterB = prop.getProperty("paraB");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String getParameterA() {
return parameterA;
}
public String getParameterB() {
return parameterB;
}
}
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* 饿汉式
* Created by jerry on 16-4-12.
*/
public class AppConfig_Hungry {
private String parameterA;
private String parameterB;
private static AppConfig_Hungry instance = new AppConfig_Hungry();
public static AppConfig_Hungry getInstance() {
return instance;
}
private AppConfig_Hungry() {
readConfig();
}
private void readConfig() {
Properties prop = new Properties();
InputStream in = null;
try {
in = AppConfig_Hungry.class.getResourceAsStream("AppConfig.properties");
prop.load(in);
this.parameterA = prop.getProperty("paraA");
this.parameterB = prop.getProperty("paraB");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public String getParameterA() {
return parameterA;
}
public String getParameterB() {
return parameterB;
}
}
其实两者差别仅在于前几行,
懒汉式:实例的初始化等到客户端需要创建实例的时候才需要new。饿汉式:只要类加载器一加载类,就进行初始化。
如果对性能要求不是特别苛刻,那么还是推荐使用饿汉式,写起来特别方便。当需要写懒汉式时,必须要注意的是 线程安全性,上述的写法为线程不安全,例如有两个线程同时访问getInstance方法,当其中一个线程刚判断 instance==null 完,进入if语句里,但没有执行instance = new AppConfig_Lazy();时,另一个线程开始判断if语句内容,发现instance为空,也将进入if语句里。那么之后会进行两次的new操作,即将会创建两个实例,不会达到单例的目的。
当然,需要修改为线程安全也很简单,只需在方法上加入synchronized 关键字即可。
public static synchronized AppConfig_Lazy getInstance() {
//首先判断实例有没有初始化
if (instance == null){
//如果没有初始化那么new一个实例
instance = new AppConfig_Lazy();
}
return instance;
}
但是如果这样进行同步,会大大降低访问速度,因为每次获取实例都要同步。更好的做法是采用“双重检查加锁”法。
五 使用 “双重检查加锁法” 改写懒汉式
双重检查加锁法实现需要用到一个关键字
volatile ,它的意思是:被volatile修饰的变量的值,将不会被本地线程缓存,所有对该变量的读写都是直接操纵内存,从而确保多个线程能正确处理该变量。
private volatile static AppConfig_Lazy instance = null;
public static AppConfig_Lazy getInstance() {
//首先判断实例有没有初始化
if (instance == null){
//同步块,线程安全地创建实例
synchronized (AppConfig_Lazy.class) {
// 再次检查实例是否存在,如果不存在才真正创建实例
if (instance == null)
instance = new AppConfig_Lazy();
}
instance = new AppConfig_Lazy();
}
return instance;
}
所谓双重检查加锁是指:并不是每次进入getInstance方法都需要同步,而是先不同步,进入方法后,先检查实例是否已经创建,这是第一次检查。如果未创建,则进入下面的同步块,进入同步块后再检查实例是否创建,这是第二次检查。这样就创建了一个线程安全的单例模式。
六 进阶的单例模式
有时我们会想,我觉得一个实例太少,可能满足不了需求,我想要控制3个实例。
可以使用Map来缓存实现单例。说到缓存,其实我们之前介绍的懒汉式单例中也用到了缓存技术,即只有第一次访问才会创建对象,其他情况读取内存即可,不过缓存中只有一个对象而已。当使用Map来实现时,就可以控制任意数量的实例。这时新的问题来了,当客户端调用的时候,我该返回哪一个实例呢?这里又设计到调度的问题,这里就不继续介绍了,具体问题具体分析。
以下的代码线程不安全,若要其成为线程安全,可参考之前做法。
import java.util.HashMap;
import java.util.Map;
/**
* 简单演示扩展的单例模式,创造3个实例
* TODO 扩展调度算法
* Created by jerry on 16-4-12.
*/
public class SingletonExtend {
/**
* 定义一个缺省的key前缀
*/
private final static String DEFAULT_PREKEY = "Cache";
/**
* 缓存实例的容器
*/
private static Map<String, SingletonExtend> map = new HashMap<String, SingletonExtend>();
/**
* 用来记录当前第几个实例
*/
private static int num = 1;
/**
* 最大实例个数
*/
private final static int MAX_NUM = 3;
private SingletonExtend() {
}
public static SingletonExtend getInstance() {
String key = DEFAULT_PREKEY + num;
SingletonExtend singletonExtend = map.get(key);
if (singletonExtend == null) {
singletonExtend = new SingletonExtend();
map.put(key, singletonExtend);
}
++num;
if (num > MAX_NUM)
num = 1;
return singletonExtend;
}
public static void main(String[] args) {
SingletonExtend s1 = getInstance();
SingletonExtend s2 = getInstance();
SingletonExtend s3 = getInstance();
SingletonExtend s4 = getInstance();
SingletonExtend s5 = getInstance();
SingletonExtend s6 = getInstance();
System.out.println("s1="+s1);
System.out.println("s2="+s2);
System.out.println("s3="+s3);
System.out.println("s4="+s4);
System.out.println("s5="+s5);
System.out.println("s6="+s6);
}
}
程序运行结果如下:
七 总结
何时选用单例模式
- 当需要控制一个类的实例只有一个时,而且客户只能通过从一个全局访问点访问它,这时可以考虑选用单例模式。