饿汉式单例
饿汉式单例，故名思意就是在类一加载时就进行创建，构造器私有并提供对外获取对象的接口。
缺点：浪费空间，并不是按需创建，创建的对象一直存在。
package com.wang.single;
// 饿汉式单例
// 类加载时就会创建，缺点是可能会浪费空间
public class Hungry {
// 构造器私有，保证只有一个对象
private Hungry() {
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
懒汉式单例
懒汉式单例：指在类加载时不进行创建，当在调用使用时才进行创建
懒汉式单例-代码1
package com.wang.single;
// 懒汉式单例
public class LazyMan {
private LazyMan() {
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance(){
if(lazyMan == null){
lazyMan = new LazyMan();
}
return lazyMan;
}
不难看出上面代码中 getInstance() 方法在多线程并发场景下是会存在问题的，可能会出现重复创建对象的问题，为解决多线程并发存在的问题我们加入了经典的双重检测锁模式，也就是常说的DCL懒汉式。
package com.wang.single;
// 懒汉式单例
public class LazyMan {
private LazyMan() {
}
private static LazyMan lazyMan;
// 双重检测锁模式的 懒汉式单例 DCL
public static LazyMan getInstance(){
if(lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan == null){
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
}
现在我们再来思考下，经过改进后的代码还有问题吗？答案是肯定的，首先在 getInstance() 中的 lazyMan = new LazyMan(); 这行代码它不是一个原子性操作。当在新建对象时，我们看似一行代码但底层却经过了3步：
- 1.分配内存空间
- 2.执行构造方法，初始化对象
- 3.把这个对象指向这个空间
这时候我们就不得不提“指令重排”的问题了。
指令重排
正常情况下执行步骤是 123
极端情况下 132
例如，线程A进来的时候执行了132
先分配了内存空间
然后把空对象指向这个空间，先占用
占用后再调用构造方法去初始化对象
走成132也没有问题，但在多线程的情况下现在忽然来了线程B
线程B发现已经占用这个空间了，它会以为不等于null
故而不走判断，直接走了方法最底下的return
但此时，lazyMan 还没有完成构造
为避免出现“指令重排”的情况，我们需要加入 volatile
package com.wang.single;
// 懒汉式单例
public class LazyMan {
private LazyMan() {
}
private volatile static LazyMan lazyMan;
// 双重检测锁模式的 懒汉式单例 DCL
public static LazyMan getInstance(){
if(lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan == null){
lazyMan = new LazyMan();
}
}
}
return lazyMan;
}
}
这才是真正的“双重检测锁” + “原子性” 的懒汉式单例。
静态内部类单例
package com.wang.single;
// 静态内部类实现单例模式
public class Holder {
private Holder() {
}
public static Holder getInstance(){
return InnerClass.HOLDER;
}
public static class InnerClass{
private static final Holder HOLDER = new Holder();
}
}
总结
其实以上我们讲的几种单例模式都不是绝对安全的，我们知道在Java中有一门无敌的存在，就是反射，就以我们“双重检测锁” + “原子性” 的懒汉式为例，使用反射进行破解
public static void main(String[] args) throws Exception {
// 使用普通方法获取对象
LazyMan instance1 = LazyMan.getInstance();
// 使用反射机制获取
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);// 无视私有构造器
LazyMan instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
System.out.println(instance1.equals(instance2));
}
最终的结果是：
com.wang.single.LazyMan@16d3586
com.wang.single.LazyMan@154617c
false
那么针对这种问题，我们应该如何解决呢？我们先来看下反射的源码，点击查看 newInstance() 的源码如下所示
@CallerSensitive
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, null, modifiers);
}
}
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) {
ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
在源码中我们注意到这两段代码
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
它进行判断，如果你的类型是一个枚举类型，那将会抛出异常提示“不能用反射创建一个枚举对象”。枚举是JDK1.5出来的，它自带单例模式。
