单例模式，这个我曾经以为掌握的很不错了的DesignPattern，最近因为我在看一道面试题的时候再次来到了我的面前，然后我又想到了我很久以前写了的一个泛型单例，然后，然后我在多线程的情况下跑了我的这个泛型单例，然后......然后跑出来了好几个对象，然后我就懵逼了！我这是在写代码么？我是在写bug吧！
废话不多说，如果你还不懂啥叫做单例模式，请看陈皓大哥的深入浅出单实例SINGLETON设计模式，如果你懂了，那么跟我走一走，看看下面我亲手写的bug。我的代码是参考了这位大哥的代码来实现的JAVA语言泛型编程实现单例模式，当时没有对并发的理解，直接改动了之后我又没有在多线程的情况下测试，导致了隐藏的bug。
package com.example.curry.intellijsystem.tools;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.ConcurrentHashMap;
/**
* Created by Curry on 17/6/26.
*/
public class Singleton<T> {
/**
* 私有构造函数，在这里显得表鸡肋，没有任何作用
* 但是处于对单例模式的尊重，要给全它定义中的，私有构造函数、私有静态自身实例，共有静态的获取单例的方法
*/
private Singleton(){}
/**
* 私有，静态，并发哈希表，用于存储所有的实例的唯一单例,而且其本身也是静态唯一的
*/
private static ConcurrentHashMap<Class, Object> map = new ConcurrentHashMap<>();
/**
* 公开，静态，泛型的获取对应类型的单例
*/
public static <T> T getDefault(Class<T> type) {
Object object = map.get(type);
if (object == null) {
synchronized (map) {
if(object == null){//两次判断，以此应付多线程的冲击
try {
/**
* 这里利用反射，将私有的构造方法改为共有的，用于创建实例，否则无法创建实例
*/
Constructor constructor = type.getDeclaredConstructor();
constructor.setAccessible(true);
object = constructor.newInstance();
map.put(type, object);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
return (T) object;
}
/**
* 根据类型移除存储在哈希表中的单例
*/
public static <T> void removeSingleton(Class<T> type) {
map.remove(type);
}
}
你运行第一次的时候觉得跑出来的是单例，但是你把程序运行10次试试，保证你怀疑人生。
或许你看了看，觉得没有问题啊，这不是双重检查版本的单例模式么？那位大哥的还是单重检查你可能觉得不够安全，但是这里双重检查了，难道还能有鬼？巧了，还真有鬼，那么问题在哪里？
问题就在于Object ob = map.get(type);，然后竟然还狗血的拿着这个ob去做双重检查？脑子有病是不是？每次线程来到这里都要new一个Object来接收map里面的type对应的对象，但是你想过没，当程序开始执行，几个线程一起来，同时走到了Object ob = map.get(type);，然后每个线程就都持有了一个ob，问题就在这里，每个线程都有ob，都是null，然后你实例化之后扔进了map，然后释放了锁，下一个线程他自己的ob是不是还是空的啊？明显是啊，线程1和线程2相互独立，你的ob实例化与否关我啥事，我只知道我自己的ob还是空的，我还得往下走，然后毫不可避免的就是，你搞出了很多个对象，根本都不是单例了。
那该咋办呢？单例写到这里了，不能毁在并发手里吧，可以这么改进，不要new那个Object对象了，按下面这么干
public static <T> T getDefault(Class<T> type) {
if (map.get(type) == null) {
synchronized (map) {
if (map.get(type) == null) {
try {
/**
* 这里利用反射，将私有的构造方法改为共有的，用于创建实例，否则无法创建实例
*/
Constructor constructor = type.getDeclaredConstructor();
constructor.setAccessible(true);
map.put(type, constructor.newInstance());
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
return (T)map.get(type);
}
这样每次判断的就是map里面的对象了，至于二次判断还是为了多线程，因为比如说有两个线程都在第一个判断那里发现了条件成立，然后
有个线程先运行，将目标对象实例化了，释放锁之后第二个线程再运行，要是不二次判断的话，就会再搞出一个实例来，这就不是单例了。
以前对网上的那些东西有很大的信任程度，很多人的博客，现在看来都不能全信，每个东西都要有自己的理解。
网友评论