大战设计模式（第二季）【2】———— 从源码看单例模式

前言

对于单例模式我们其实已经非常熟悉了，如果不熟悉的话，那你随便百度一下就能看的一大堆关于单例模式的介绍。单例模式的实现是当前设计模式中可以说实现最简单的一种模式了，也很容易理解，但是其实单例模式并非你想的那么简单哦。
下面就从几个实际的源码中来看看，单例模式在什么样的情况下会被使用。

单例模式（高级点）

问你下面几个问题，如果你对这几个问题烂熟于心，那么证明你真的了解单例模式。

1、有几种常见的实现单例模式的方法？
2、通过序列化和反序列化可以破坏某些单例模式
3、通过反射可以破坏某些单例模式
4、可以用枚举实现单例模式，并且非常安全
5、如何针对每一个线程单独创建一个单例

单例模式的实现

单例模式的实现有很多方式，这里只是个人做一个记录，供参考。

package com.linkinstars.singleton;

/**
 * （双重检查）单例模式
 * @author LinkinStar
 */
public class DoubleCheckSingleton {
    
    private DoubleCheckSingleton(){}
    
    public volatile static DoubleCheckSingleton doubleCheckSingleton = null;
    
    public static DoubleCheckSingleton getInstance(){
        if (doubleCheckSingleton == null) {
            synchronized(DoubleCheckSingleton.class){
                if (doubleCheckSingleton == null) {
                    doubleCheckSingleton = new DoubleCheckSingleton();
                }
            }
        }
        
        return doubleCheckSingleton;
    }
}

package com.linkinstars.singleton;

/**
 * 饿汉式单例
 * @author LinkinStar
 */
public class HungrySingleton {
    private final static HungrySingleton INSTANCE = new HungrySingleton();

    public static HungrySingleton getInstance() {
        return INSTANCE;
    }

    private HungrySingleton() {
        if (INSTANCE != null) {
            throw new RuntimeException("Can't create singleton by reflect.");
        }
    }
}

package com.linkinstars.singleton;

/**
 * 静态内部类实现单例模式
 * @author LinkinStar
 */
public class StaticInnerClassSingleton {
    private static class InnerClass {
        private static StaticInnerClassSingleton staticInner = new StaticInnerClassSingleton(); 
    }
    
    public StaticInnerClassSingleton getInstance(){
        return InnerClass.staticInner;
    }
    
    private StaticInnerClassSingleton(){}
}

package com.linkinstars.singleton;

/**
 * 枚举实现单例模式
 * @author LinkinStar
 */
public enum EnumSingleton {
    /** 单例 **/
    INSTANCE;
    
    private Object data;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
    
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

package com.linkinstars.singleton;

/**
 * 单线程级别的单例
 * @author LinkinStar
 */
public class ThreadLocalSingleton {
    public static final ThreadLocal<ThreadLocalSingleton> THREAD_LOCAL_SINGLETON_THREAD_LOCAL 
            = ThreadLocal.withInitial(ThreadLocalSingleton::new);
    
    private ThreadLocalSingleton(){
        
    }
    
    public static ThreadLocalSingleton getInstance(){
        return THREAD_LOCAL_SINGLETON_THREAD_LOCAL.get();
    }
}

从jdk中的Runtime来看饿汉式单例

jdk中有一个Runtime的类，这个类用于获取java程序运行时的一些环境，如内存等信息。这些获取信息的方法很多都是会调用底层原生的native方法。
如：Runtime.getRuntime().maxMemory();
然后我们进入Runtime可以看见源码中：

这个是标准的饿汉式的单例
因为java程序运行时，如果要获取运行时的环境信息，总需要一个载体，并且在任何地方获取的都应该是一样的，所以用一个单例来维护这个信息，并且提供些方法，再好不过了。

从Spring的getSingleton方法来看单例

Spring单例模式的bean只会创建一次，如果再获取该bean，是直接从单例缓存中获取，该过程就在getSingleton(String beanName)中。

这里的方法需要你细细品读，我要说明的是，单例模式肯定有自己的好处，不然spring为什么bean默认是单例的呢？很简单的一点是因为单例的速度快，并且对象少，占用的内存就少，如果是多例的，每次使用需要进行创建会耗时间，并且消耗内存。
但是同时单例模式也有相应的问题，就是多线程访问的时候会有线程安全的问题，多个线程操作私有变量的时候就会出现。所以在使用的单例模式的时候也要同时考虑到线程安全的问题。