目录
一、什么讲单例模式
单例模式，最简单的理解是对象实例只有孤单的一份，不会重复创建实例。
这个模式已经很经典了，经典得我不再赘述理论，只给简单注释，毕竟教科书详尽太多。
解决 sonar RSPEC-2168 异味的时候，发现目前业界推荐的单例模式和教科书上的已经有了较大差异，双重锁定不再推荐，甚至业内认为的最优方案不在sonar的推荐里
于是提笔记录，顺带补充了自己对多线程单例的理解 。
二、经典的单线程单例
这个部分没有改动，简单而经典，大致源码如下
public final class SignUtil {
/**
* 需要保持单例的对象
*/
private static Object object;
/**
* 只允许SignUtil.getInstance获取对象,也就是入口唯一
*/
private SignUtil() {
}
/**
* 对象的唯一出口 调用时才初始化（懒加载）
* @return Object 确保单线程情况下这里出去就是初始化好的
*/
public static Object getInstance() {
if (null == object) {
object = new Object();
}
return object;
}
/**
* 内部函数也必须使用 getInstance这个入口
*/
public static String getString() {
return getInstance().toString();
}
}
三、经典的双重锁定多线程单例 (JDK5-JDK7继续适用)
public final class SignUtil {
/**
* 需要保持单例的对象
* 这里需要声明对象是易失的,因为object = new Object()不是一个原子操作,是被分拆为了实例化和初始化,一个申请空间,一个分配值
* 那么就有可能出现 C在第三瞬间进入getInstance函数,发现null!=object,此时对象实例化了但没初始化就直接返回,是个高危操作
*/
private volatile static Object object;
/**
* 只允许SignUtil.getInstance获取对象,也就是入口唯一
*/
private SignUtil() {
}
/**
* 对象的唯一出口
*
* @return Object 多线程情况下这里出去就是初始化好的
*/
public static Object getInstance() {
// 第0瞬间 A B 两个线程同时初始化,一看都是null嘛
if (null == object) {
// 第1瞬间 A B都进来了,因为不能重复初始化，所以被synchronized锁约束开始竞争.
// A 赢了SignUtil的对象锁,B 只能等着
synchronized (SignUtil.class) {
// 这里为什么不直接object = new Object()呢?
// 因为B还等着呢,直接初始化就拦不住B再来一次初始化了.
if (null == object) {
// 第2瞬间, A终于初始化成功,且B不会重新初始化了.
object = new Object();
// 第3瞬间，因为object被volatile约束了，可以视为原子操作，补上最后一个漏洞，成功返回。
}
}
}
return object;
}
/**
* 内部函数也必须使用 getInstance这个入口
*/
public static String getString() {
return getInstance().toString();
}
}
四、 JDK8 以后的多线程单例
可以看到，三的要点太多了，很经典的双重锁定，但是不够简单优雅。目前更推荐下面两种格式
4.1 synchronized变为轻量级锁
JDK8 带来的一个特性之一即是synchronized关键字，从原来的monitor重量级锁，转变成了由偏向锁进行逐级升级到重量级锁。换句话说，使用synchronized的代价被降低了，我们可以将上面的函数进行一个改进，让它保持简单和优雅。
但是代价依旧存在，以下适合并发冲突不严重的项目。
public final class SignUtil {
/**
* 需要保持单例的对象
*/
private static Object object;
/**
* 只允许SignUtil.getInstance获取对象,也就是入口唯一
*/
private SignUtil() {
}
/**
* 对象的唯一出口 是的,仅比单线程版多了一个synchronized
* @return Object 由于synchronized,同一瞬间只能有一个对象进行获取实例
*/
public static synchronized Object getInstance() {
if (null == object) {
object = new Object();
}
return object;
}
/**
* 内部函数也必须使用 getInstance这个入口
*/
public static String getString() {
return getInstance().toString();
}
}
4.2 利用静态内部类的初始化特性
很巧妙地利用了jvm的类加载机制。那就是静态内部类的延迟加载性完成单例。
public final class SignUtil {
/**
* 利用jvm的初始化规则 静态内部类的静态内部对象,只有在调用时才对静态类开始初始化,
* 类的初始化过程是线程安全的,所以也只有一个线程能进行初始化
*/
private static class Node {
/**
* 在读写调用时才真正初始化,也就是懒加载
*/
private static final Object object = new Object();
}
/**
* 只允许SignUtil.getInstance获取对象,也就是入口唯一
*/
private SignUtil() {
}
/**
* 不再是对象的唯一出口,其他地方也只要读写都能完成初始化
*
* @return Object 调用时,会触发内部静态类的初始化,返回时,初始化已完成
*/
public static Object getInstance() {
return Node.object;
}
/**
* 内部函数终于不用再依赖 getInstance这个入口
*/
public static String getString() {
return Node.object.toString();
}
}
五、 有没有办法让单例模式不单例？
听起来很魔鬼，但实际上，上述的多线程程单例都有两个共同的缺陷可以做到：a 反射Constructor::setAccessible将私有构造函数改为公有函数 b.序列化时还是会返回多个实例。
解决方法为改造构造函数和申明readResolve函数，参考如下，解决方案是通用的。
public final class SignUtil {
private static volatile boolean init = false;
private static class Node {
private static final Object object = new Object();
}
/**
* 添加一个volatile的变量去判断,防止反射初始化
* 第二次初始化会抛出类强制转换异常 当然你也可以用其他运行时异常
*/
private SignUtil() {
if (!init) {
init = true;
} else {
throw new ClassCastException();
}
}
public static Object getInstance() {
return Node.object;
}
public static String getString() {
return Node.object.toString();
}
/**
* 反序列化时直接返回单例的对象,这么写的原因在 ObjectInputStream::readUnshared里
*/
private Object readResolve() {
return Node.object;
}
}
六、枚举单例
6.1 单元素枚举单例
和4.2一样，《Effective Java 》找到了另一种利用jvm类加载机制实现单例的方法：单元素枚举单例。
这里有几个前提：
- Enum禁用了默认序列化。Enum::readObject、Enum::readObjectNoData约束了枚举对象的默认反序列化，保证序列化安全
- Enum提供了自己的序列化。Enum::toString 返回的是属性名称name，再通过Enum::valueOf把name转回实例，保证了枚举不会被“退货”（这个直译了，大概是final且不会被clone的意思）。
- 这里说一下valueOf的底层是Class::enumConstantDirectory,作用是调用时，生产一个Map<name, 枚举>的映射,而这个map很像单线程单例模式，但他不是静态共享变量，所以是线程安全的，
不得不说，单元素枚举的确成功避免了重重的繁琐，但代价是没有了懒加载的特性，变成了饿汉模式
public enum SignUtil {
/**
* 从javap的反编译结果看,会变成一个类公开的静态变量,也就是饿汉模式
* public static final SignUtil INSTANCE = new SignUtil();
* 也就是会在加载类时直接初始化INSTANCE对象,而object对象是在构造时作为内部变量初始化,而构造函数是由jvm保证的
*/
INSTANCE;
/**
* 由于INSTANCE单例,所以object才是单例的
*/
private final Object object = new Object();
public Object getInstance() {
return object;
}
public String getString() {
return object.toString();
}
}
补一下javap反编译后的结果
public final class SignUtil extends java.lang.Enum<SignUtil> {
public static final SignUtil INSTANCE;
private final java.lang.Object object;
private static final SignUtil[] $VALUES;
public static SignUtil[] values();
public static SignUtil valueOf(java.lang.String);
private SignUtil(java.lang.Object);
public java.lang.Object getInstance();
public java.lang.String getString();
static {};
}
6.2 多元素枚举的单例呢？
由于多元素枚举的构造函数可以被反射修改成公用函数并设置object，但由于INSTANCE和object都是final约束的，所以修改就会报错，以此保证了单例性。
所以按照理解 多元素枚举也能完成单例，只是适用场景偏少
public enum SignUtil {
/*
* 对的，唯一的区别就是由无参变成了有参构造，本质是不变的饿汉
* public static final SignUtil INSTANCE = new SignUtil(new Object());
*/
INSTANCE(new Object()),
OTHER(new Object());
private final Object object;
private SignUtil(Object object) {
this.object = object;
}
public Object getInstance() {
return this.object;
}
public String getString() {
return this.object.toString();
}
}