单例模式(Singleton Pattern)的定义:
确保某个类只有一个实例,而且自行实例化并向整个系统提供整个实例。
通用类图如下:
Singleton类成为单例类,通过使用private的构造函数确保在应用中只产生一个实例,并且是自行实例化的。其通用代码如下:
package 单例模式;
/**
* 单例模式的通用代码
*/
public class Singleton {
private static final Singleton singletom = new Singleton();
//限制产生多个对象
private Singleton() {
}
//通过该方法获取实例对象
public static Singleton getSingletom() {
return singletom;
}
//类中的其他方法,尽量是static
public static void doSomething() {
}
}
单例模式的应用
单例模式的优点
- 由于单例模式在内存中只有一个实例,减少内存开支。
- 由于单例模式只生成一个实例,所以减少了系统的性能开销。
- 可以避免对资源的多重占用。
- 可以在系统设置全局访问点。
单例模式的缺点
- 单例模式一般没有借口,扩展困难。若要扩展,除了修改代码外基本上没有第二种途径。
- 单例模式对测试不利。在并行开发环境中,如果单例模式没有完成,是不能进行测试的,没有接口也不能使用mock的方式虚拟一个对象。
- 与单一职责原则有冲突,单例模式把“要单例”和业务逻辑融合在一个类中。
单例模式使用场景
- 要求生产唯一序列号的环境。
- 在项目中需要一个共享访问点或共享数据,比如Web页面上的计数器。
- 创建对象需要消耗的资源过多,如I/O和数据库等资源。
- 需要定义大量的静态资源和静态方法(如工具类)的环境(当然,也可以直接声明为static的方式)。
单例模式的注意事项
在高并发情况下,注意单例的同步问题
上面的例子不会产生多个实例的情况,但是如下实例为线程不安全的单例:
public class Singleton {
private static Singleton singletom = null;
//限制产生多个对象
private Singleton() {}
//通过该方法获取实例对象
public static Singleton getSingletom() {
if(singleton == null)
singleton = new Singleton();
return singleton;
}
}
该单例在低并发的情况下不会出现问题,若系统压力过大,并发量增大时则可能在内存中出现多个实例。如一个线程A执行到singleton = new Singleton(),但还没有获得对象(对象初始化是要时间的),而此时第二个线程B也在执行,并判断singleton !=null,那么线程B将继续运行下去而又创建一个新的对象。
可以使用Synchronized关键字来解决这个问题,但是在访问频繁的情况下性能开销很大,建议使用最上面给出的方式。
考虑对象的复制问题
在Java中对象默认不可复制,需要实现Cloneable接口并实现clone方法。对象复制是不需要调用类的构造函数,因此即使构造函数私有依然可以被复制。一般情况下,很少有单例会主动要求实现Cloneable接口。
单例模式实例
皇帝只有一个,大臣参拜皇帝,用单例来实现此模型:
皇帝类:
public class Emperor {
private static final Emperor emperor = new Emperor();//初始化一个皇帝
//构造方法私有,不允许有多个皇帝
private Emperor() {
}
//获取单一实例
public static Emperor getInstance() {
return emperor;
}
//动作
public static void say() {
System.out.println("我是皇帝");
}
}
臣子类:
public class Minister {
public static void main(String[] args) {
for (int day = 0; day < 3; day++) {
Emperor emperor = Emperor.getInstance();
emperor.say();
}
}
}
臣子每天都参拜同一个皇帝。
单例模式的扩展
假设皇帝有两位,需要指定固定数量实例的单例模式。
固定数量的皇帝类:
import java.util.ArrayList;
import java.util.Random;
/**
* 固定数量的皇帝类
*/
public class Emperor2 {
//定义最多能产生的实例数量
private static int maxNumOfEmperor = 2;
//每个皇帝都有名字,使用一个ArrayList来容纳,每个对象的私有属性
private static ArrayList<String> nameList = new ArrayList<>();
//定义一个列表,容纳所有的皇帝实例
private static ArrayList<Emperor2> emperor2List = new ArrayList<>();
//当前皇帝的序号
private static int countNumOfEmperor = 0;
//产生所有的对象
static {
for (int i = 0; i < maxNumOfEmperor; i++) {
emperor2List.add(new Emperor2("黄" + (i + 1) + "帝"));
}
}
private Emperor2() {
//不能产生两个皇帝
}
//传入皇帝名称,建立一个皇帝对象
private Emperor2(String name) {
nameList.add(name);
}
//随机获得一个皇帝对象
public static Emperor2 getInstance() {
Random random = new Random();
//随机拉出一个皇帝,只要是个精神领袖就成
countNumOfEmperor = random.nextInt(maxNumOfEmperor);
return emperor2List.get(countNumOfEmperor);
}
//皇帝发话了
public static void say() {
System.out.println(nameList.get(countNumOfEmperor));
}
}
臣子参拜皇帝的过程:
public class Minister2 {
public static void main(String[] args) {
//定义五个大臣
int ministerNum = 5;
for (int i = 0; i < ministerNum; i++) {
Emperor2 emperor = Emperor2.getInstance();
System.out.println("第" + (i + 1) + "个大臣参拜的是:");
emperor.say();
}
}
}
这种需要产生固定数量的单例模式叫多例模式,它是单例的一种扩展。我们可以在设计时决定内存中有多少个实例,方便系统进行扩展,修正单例可能存在的性能问题,通过系统的响应速度。例如读取文件,我们可以在系统启动时创建多个reader实例,然后需要在读取文件的时候可以快速响应。
参考文献:《设计模式之禅》