单例模式

单例模式(Singleton Pattern)是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。

  1. 某个类只能有一个实例。
  2. 它必须自行创建这个实例。
  3. 它必须自行向整个系统提供这个实例。

单例模式关键点:

  • 构造函数私有化(不让外部创建此类对象)。
  • 通过一个静态方法或枚举返回单例类对象。
  • 多线程环境下,确保单例(难点)。
  • 反序列化不会重新构建对象。

饿汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Singleton {
// 单例对象
private final static Singleton INSTANCE = new Singleton();

// 或
// private final static Singleton INSTANCE;
// static {
// INSTANCE = new Singleton();
// }

// 私有构造方法
private Singleton() {
}

// 公有静态方法用于获取单例对象
public static Singleton getInstance() {
return INSTANCE;
}
}

线程安全。但是没使用它时,就已经建立了对象,开销内存。

懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
// 单例对象
private static Singleton INSTANCE = null;

// 私有构造方法
private Singleton() {
}

// synchronized关键字修饰静态方法
public static synchronized Singleton getInstance() {
if (null == INSTANCE) {// 空值判断
INSTANCE = new Singleton();
}
return INSTANCE;
}
}

在第一次调用getInstance()时,创建单例对象。synchronized关键字修饰,使getInstance()是一个同步方法。保证多线程情况下单例对象的唯一。但是,同步会耗费资源。

双检锁式(Double Check Lock(DCL))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Singleton {
// 单例对象,volatile关键字保证INSTANCE的原子性
private volatile static Singleton INSTANCE = null;

// 私有构造方法
private Singleton() {
}

// 两次空值检查,synchronized关键字同步
public static Singleton getInstance() {
if (null == INSTANCE) {
synchronized (Singleton.class) {
if (null == INSTANCE) {
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}

语句INSTANCE = new Singleton();在编译时的步骤如下:

  1. 给Singleton的实例分配内存。
  2. 调用Singleton()的构造函数,初始化成员字段。
  3. 将INSTANCE 对象指向分配的内存空间(此时对象非空)。

Java编译器允许处理器乱序执行。上诉的2,3两步的顺序可能被打乱。打乱后,非空判断的线程不安全。在JDK1.5之后,调整了JVM,具体化了volatile关键字,表示此操作是一个原子操作,不能中间被分割执行。使用volatile关键字会影响性能。

静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Singleton {
// 内部类,包含单例的对象
private static class SingletonHolder {
public static final Singleton INSTANCE = new Singleton();
}

// 私有构造方法
private Singleton() {
}

// 公有静态方法用于获取单例对象
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}

第一次加载Singleton时,SingletonHolder不会被加载。只用调用getInstance()时,才加载SingletonHolder,并创建INSTANCE推荐大家使用

枚举式

1
2
3
public enum SingletonEnum {
INSTANCE;
}

虽说代码简单,enum的实质也是class(编译时,会先翻译成一个class)。优点是反序列化也不会重新生成新的实例。

前几种方式,如果要避免反序列化也不会重新生成新的实例。需要重写:

1
2
3
private Object readResolve() throws ObjectStreamException{
return INSTANCE;
}

单例管理类

一个程序可能有多个单例对象。先建立一个上诉管理类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SingletonManager {
// 容器
private static Map<String, Object> objMap = new HashMap<String, Object>();

// 私有构造方法
private SingletonManager() {
}

// 注册单例
public static void ascendSingleton(String key, Object instance) {
if (!objMap.containsKey(key)) {
objMap.put(key, instance);
}
}

// 获得单例对象
public static Object getInstance(String key) {
return objMap.get(key);
}
}

通过注册,可以管理多种类型的单例,使用统一接口,隐藏具体实现。
使用时:

1
2
//注册单例
SingletonManager.ascendSingleton("SingletonKey",Singleton.getInstance());

1
2
//获得单例对象
Singleton singleton = SingletonManager.getInstance("SingletonKey");

优点

  • 只有一个对象,全局使用。
  • 只需要建立一次,占一个内存,节约资源。

缺点

  • 没有接口,难以扩展。
  • 生命周期长,如果引用短生命周期对象会内存泄漏。

补充

通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。

附件

设计模式Demo
GitHub源码:https://github.com/wzmyyj/Design-Pattern