单例模式
是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例
简介
单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。
动机
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。 [3]
如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。
要点
显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
示例
读取数据库配置文件 只读取一次
database.properties 配置文件
1
2
| username=root
password=simon
|
ConfigManagerHungry 工具类 单例饿汉模式
类初始化自行实例化,不存在线程不安全。不具备延迟加载特性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| package com.util;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ConfigManagerHungry {
private static ConfigManagerHungry configManagerHungry = new ConfigManagerHungry();
private static Properties properties;
private ConfigManagerHungry() {
System.out.println("饿汉模式 ConfigManagerHungry ------>>>> 创建");
String configFile = "database.properties";
properties = new Properties();
InputStream is = ConfigManagerHungry.class.getClassLoader().getResourceAsStream(configFile);
try {
properties.load(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static ConfigManagerHungry getConfigManagerHungry() {
return configManagerHungry;
}
public String getValue(String key) {
return properties.getProperty(key);
}
}
|
ConfigManagerIdler 工具类 单例懒汉模式
具备延迟加载特性。线程不安全
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| package com.util;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ConfigManagerIdler {
private static ConfigManagerIdler configManagerIdler;
private static Properties properties;
private ConfigManagerIdler() {
String configFile = "database.properties";
properties = new Properties();
InputStream is = ConfigManagerIdler.class.getClassLoader().getResourceAsStream(configFile);
try {
properties.load(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static ConfigManagerIdler getConfigManagerIdler() {
if (null == configManagerIdler) {
System.out.println("懒汉模式 ConfigManagerIdler ------>>>> 创建");
configManagerIdler = new ConfigManagerIdler();
}
return configManagerIdler;
}
public String getValue(String key) {
return properties.getProperty(key);
}
}
|
ConfigManager 工具类 单例模式
结合饿汉模式与懒汉模式的特性。及具有延迟加载特性并线程安全
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| package com.util;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ConfigManager {
private static ConfigManager configManager;
private static Properties properties;
private ConfigManager() {
String configFile = "database.properties";
properties = new Properties();
InputStream is = ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
try {
properties.load(is);
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static class ConfigManagerHelper {
private static final ConfigManager INSTANCE = new ConfigManager();
}
public static ConfigManager getConfigManager() {
if (null == configManager) {
System.out.println("单例模式 ConfigManager ------>>>> 创建");
configManager = ConfigManagerHelper.INSTANCE;
}
return configManager;
}
public String getValue(String key) {
return properties.getProperty(key);
}
}
|
Test 测试类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| package com.test;
import com.util.ConfigManager;
import com.util.ConfigManagerHungry;
import com.util.ConfigManagerIdler;
public class Test {
public static void main(String[] args) {
System.out.println("one -----------------");
System.out.println(getConfigManager());
System.out.println(getConfigManagerHungry());
System.out.println(getConfigManagerIdler());
System.out.println("two -----------------");
System.out.println(getConfigManager());
System.out.println(getConfigManagerHungry());
System.out.println(getConfigManagerIdler());
}
public static String getConfigManager() {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("username : " + ConfigManager.getConfigManager().getValue("username") + "\n");
stringBuffer.append("password : " + ConfigManager.getConfigManager().getValue("password") + "\n");
return stringBuffer.toString();
}
public static String getConfigManagerHungry() {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("username : " + ConfigManagerHungry.getConfigManagerHungry().getValue("username") + "\n");
stringBuffer.append("password : " + ConfigManagerHungry.getConfigManagerHungry().getValue("password") + "\n");
return stringBuffer.toString();
}
public static String getConfigManagerIdler() {
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("username : " + ConfigManagerIdler.getConfigManagerIdler().getValue("username") + "\n");
stringBuffer.append("password : " + ConfigManagerIdler.getConfigManagerIdler().getValue("password") + "\n");
return stringBuffer.toString();
}
}
|
控制台输出结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| one -----------------
单例模式 ConfigManager ------>>>> 创建
username : root
password : simon
饿汉模式 ConfigManagerHungry ------>>>> 创建
username : root
password : simon
懒汉模式 ConfigManagerIdler ------>>>> 创建
username : root
password : simon
two -----------------
username : root
password : simon
username : root
password : simon
username : root
password : simon
|
控制台输出可以看到，三个工具类的通过单例模式可以保证系统中，应用该模式的类一个类只有一个实例。即一个类只有一个对象实例