单例模式踩坑

单例模式，这个我曾经以为掌握的很不错了的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里面的对象了，至于二次判断还是为了多线程，因为比如说有两个线程都在第一个判断那里发现了条件成立，然后
有个线程先运行，将目标对象实例化了，释放锁之后第二个线程再运行，要是不二次判断的话，就会再搞出一个实例来，这就不是单例了。

以前对网上的那些东西有很大的信任程度，很多人的博客，现在看来都不能全信，每个东西都要有自己的理解。