正文
Java设计模式之单例模式 - Singleton
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
用来创建独一无二的，是能有一个实例的对象的入场券。告诉你一个好消息，单例模式的类图可以说是所有模式的类图中最简单的，事实上，它的类图上只有一个类！但是，可不要兴奋过头，尽管从类设计的视角来说很简单，但是实现上还是会遇到相当多的波折。所以，系好安全带，出发了！
more
介绍
定义
单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
常用情景
有些对象其实我们只需要一个，比如：windows的任务管理器，项目中的读取配置文件的对象，数据库连接池，spring中的bean默认也是单例，线程池（threadpool），缓存（cache），对话框，处理偏好设置和注册表（registry）的对象，日志对象，充当打印机，显卡等设备的驱动程序的对象。事实上，这类对象只能有一个实例，如果制造出多个实例，就会导致许多问题产生，例如：程序的行为异常，资源使用过量，或者是不一致的结果。
要点
优点
-
单例模式存在一个全局访问点，所以优化共享资源；
-
只生成一个实例，减少了开销，对于一些需要频繁创建和销毁的对象，单例模式可以提高系统性能。
缺点
-
由于单例模式中没有抽象层，因此扩展困难；
-
职责过重，在一定程度上违背了“但一职责原则”。
类图
在java中实现单例模式需要注意以下三点：
- 私有的构造器；
- 一个静态方法；
- 一个静态变量。
单例模式的实现
饿汉式
代码实现
/** 通过饿汉式创建单例模式
* 当前类只能创建一个对象
* 天然线程安全（类只要被加载，就会被加载到全局变量中。所以饿汉式就是及时加载，不能实现懒加载）
*/
public class SingleHungry {
//提供一个静态的全局变量作为访问该实例的入口
private static SingleHungry instance = new SingleHungry();
/**
* 构造器私有，不让外部通过new创建实例
*/
private SingleHungry() {}
/**
* 对外提供静态的方法，用来获取该类的实例
*/
public static SingleHungry getInstance() {
return instance;
}
}
要点
代码实现
/** 通过饿汉式创建单例模式
* 当前类只能创建一个对象
* 天然线程安全（类只要被加载，就会被加载到全局变量中。所以饿汉式就是及时加载，不能实现懒加载）
*/
public class SingleHungry {
//提供一个静态的全局变量作为访问该实例的入口
private static SingleHungry instance = new SingleHungry();
/**
* 构造器私有，不让外部通过new创建实例
*/
private SingleHungry() {}
/**
* 对外提供静态的方法，用来获取该类的实例
*/
public static SingleHungry getInstance() {
return instance;
}
}
要点
优点：线程安全；
缺点：不能懒加载。
懒汉式
代码实现
/**
* 懒汉式，完成单例模式：
* 静态的全局变量，初始化放在了静态方法中，延迟产生了实例
* 延迟加载
* 线程不安全
*/
public class Singlelazy {
//提供一个静态的全局变量作为访问该实例的入口，但不立即加载
private static Singlelazy instance = null;
/**
* 构造器私有
*/
private Singlelazy() {
System.out.println("构造器被调用了");
}
/**
* 提供方法获取该类的实例
* @return
*/
public static Singlelazy getInstance() {
//先查看是否存在对象，不存在则创建
if(instance == null) {
instance = new Singlelazy();
}
return instance;
}
}
/**
* 懒汉式，完成单例模式：
* 静态的全局变量，初始化放在了静态方法中，延迟产生了实例
* 延迟加载
* 线程不安全
*/
public class Singlelazy {
//提供一个静态的全局变量作为访问该实例的入口，但不立即加载
private static Singlelazy instance = null;
/**
* 构造器私有
*/
private Singlelazy() {
System.out.println("构造器被调用了");
}
/**
* 提供方法获取该类的实例
* @return
*/
public static Singlelazy getInstance() {
//先查看是否存在对象，不存在则创建
if(instance == null) {
instance = new Singlelazy();
}
return instance;
}
}
以上代码存在的问题如图：
这段代码是线程不安全的，当有多个线程同时访问该代码时，会出现创建多个实例的情况。
为了方便理解，我以Head First设计模式中的图来介绍：
以上模拟了多线程问题的运行步骤，只是对象的名称不一样而已，相信对你来说是没问题的。
解决思路1：
加锁。锁方法
问题：可以解决问题，但锁住整个方法的粒度太大了，效率较低。不推荐使用
解决思路2：
加锁。锁代码块，先判断后锁
问题：不能解决问题，以上方式锁的粒度变小了，但是并不能产生一个实例。原因：多个线程判断之后全局变量都是null，进入后都开始等锁。线程1出去，线程2进来继续实例化，所以得到的对象是多个。
解决思路3:
加锁。锁代码块，先锁后判断。
以上方式解决了问题，当有多个线程同时访问getInstance()。保证了多个线程是以流式，次序性的进入当前方法来获取该类的实例。那么效率一样很低。而且多个线程同时等待。
上面的解决方法似乎都不怎么好，那么有没有一种更好的方法来解决懒汉式的多线程安全问题呢？请继续探索... ...
双重检测（双重校验锁）
代码实现
public class Singlelazy {
/*
* 双重检测(双重校验锁)
* 延迟加载
* 线程安全
*/
private static volatile Singlelazy instance;
/*
* 构造器私有
*/
private Singlelazy() {
System.out.println("构造器被调用了");
}
public static Singlelazy getInstance() {
if(instance == null) {
synchronized (Singlelazy.class) {
if(instance == null) {
instance = new Singlelazy();
}
}
}
return instance;
}
}
要点
public class Singlelazy {
/*
* 双重检测(双重校验锁)
* 延迟加载
* 线程安全
*/
private static volatile Singlelazy instance;
/*
* 构造器私有
*/
private Singlelazy() {
System.out.println("构造器被调用了");
}
public static Singlelazy getInstance() {
if(instance == null) {
synchronized (Singlelazy.class) {
if(instance == null) {
instance = new Singlelazy();
}
}
}
return instance;
}
}
volatile关键字确保：当instance变量被初始化成Singleton实例时，多个线程正确地处理instance变量。
值得注意的是：很不幸地，在jdk1.5之前的版本，许多JVM对于volatile关键字的实现会导致dcl（double check locking）失效。如果你不能使用jdk1.4之后的版本，就请不要利用此技巧实现单例模式。
双重检测很好的解决了懒汉式多线程安全问题，可以和之前的几种解决思路对比一下，思考一下优点在哪里！
解决思路:
我们知道为了解决这个线程安全问题，必须加锁，并且必须先锁后判断，思路3已经解决了问题，为了进一步优化代码执行效率，我们再来改进一下代码：
我们在锁的外面再加一层对全局变量的判断，这么做的效果是什么呢？当有多个线程来访问时，例如：
- 线程1，线程2同时进入该方法；
- 经过最外面的判断后，发现还没有创建实例，这时就会依次执行锁里的逻辑，并创建了实例；
- 假如这时线程3进入该方法，执行最外面的判断，发现已经创建了实例，这时候直接返回就可以了，并不需要等锁。
静态内部类（饿汉式的变种）
代码实现
/*
* 静态内部类创建单例（利用类加载机制，保证线程安全问题）
* 线程安全
* 懒加载
*/
public class SingleInner {
private SingleInner() {}
private static class SingleInnerHolder{
private static SingleInner instance = new SingleInner();
}
public static SingleInner getInsstance() {
return SingleInnerHolder.instance;
}
}
要点
/*
* 静态内部类创建单例（利用类加载机制，保证线程安全问题）
* 线程安全
* 懒加载
*/
public class SingleInner {
private SingleInner() {}
private static class SingleInnerHolder{
private static SingleInner instance = new SingleInner();
}
public static SingleInner getInsstance() {
return SingleInnerHolder.instance;
}
}
和饿汉式一样采用的是classLoader机制，保证了线程安全问题，但不同的是，静态内部类同样满足懒加载（当调用getInsstance()方法时，实例才会被创建）。
枚举实现
代码实现
public enum SingleEnum {
//定义示例化的单例对象
INSTANCE;
/*
* 对象执行的功能
*/
public void getInstance() {
}
}
要点
public enum SingleEnum {
//定义示例化的单例对象
INSTANCE;
/*
* 对象执行的功能
*/
public void getInstance() {
}
}
枚举类的单例模式，不存在出现序列化，反射构建对象的漏洞（前面几种单例实现方式都存在此问题）。不能懒加载。默认情况枚举实例的创建都是线程安全，但是实例对象实现的方法，需要自己保证线程安全问题。
反射，序列化与单例的关系
反射
我们以饿汉式为例，如下图：
通过反射获取的s3和通过饿汉式获取的s1,s2，并不是同一个实例，那么有什么办法可以解决反射对单例的影响呢！请看下面：
解决方法：
我们通过改变饿汉式构造方法的方式，来解决这个问题：
调用时抛出异常：
序列化
依旧以饿汉式为例，如下图：
通过序列化，反序列化获取的s3和通过饿汉式获取的s1,s2，并不是同一个实例，那么有什么办法可以解决序列化，反序列化对单例的影响呢！请看下面：
通过在饿汉式中加入此方法，就可以解决这个问题：
类加载器
每个类加载器都定义了一个命名空间，如果有两个以上的类加载器，不同的类加载器可能会加载同一个类，从整个程序来看，同一个类会被加载多次，如果这样的事发生在单例上，就会产生多个单件并存的怪异现象，所以，如果程序中有多个类加载器又同时使用了单例模式，那么，请自行指定类加载器，并指定同一个类加载器。
创建的构建单例模式的方式比较
-
饿汉式 效率较高 不能懒加载 线程安全 调用率高
-
懒汉式 效率较低 懒加载 线程不安全
-
双重检测（双重校验锁）懒汉式的一个变种 效率较高 懒加载 线程安全
-
静态内部类 饿汉式的变种 效率较高 懒加载 线程安全
-
枚举 效率较高 线程安全 不能懒加载
用法总结
-
懒汉式效率最低；
-
占用资源较少 不需要懒加载 枚举优先 饿汉式；
-
占用资源较多 需要懒加载 静态内部类优先 懒汉式（优先使用DCL）。
结语
- 懒汉式效率最低；
- 占用资源较少 不需要懒加载 枚举优先 饿汉式；
- 占用资源较多 需要懒加载 静态内部类优先 懒汉式（优先使用DCL）。
结语
设计模式源于生活
