设计模式之单例模式（JDK，Spring源码样例）

定义

单例模式（Singleton Pattern）：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。
在Java中，应用程序的运行环境、应用程序的配置对象、多线程的线程池、数据库的连接池、网站的计数器、程序中的缓存等常常被设计成单例。
单例模式有3个特点：

1. 单例类只有一个实例对象；
2. 该单例对象必须由单例类自行创建；
3. 单例类对外提供一个访问该单例的全局访问点。

优点

1. 在内存里只有一个实例，减少了内存开销
2. 可以避免对资源的多重占用
3. 设置全局访问点，严格控制访问

缺点

1. 单例模式一般没有接口，扩展困难。如果要扩展，除了修改原来的代码，没有第二种途径，违背开闭原则。
2. 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
3. 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

应用场景

对于Java来说，单例模式可以保证在一个JVM中只存在单一实例。单例模式的引用场景主要有以下几个方面：

1. 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少GC。
2. 某类只要求生成一个对象的时候，如果一个班中的班长，每个人的身份证号等。
3. 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
4. 某类需要频繁实例化，而创建的对象又频繁被销毁时，如多线程的线程池、网络连接池等。
5. 频繁访问数据库或文件的对象。
6. 对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
7. 当对象需要被共享的场景。由于单例模式只允许创建一个对象， 共享该对象可以节省内存，并加快对象访问速度。如Web中的配置对象， 数据库中的连接池等。

实现样例

1.懒汉式

public class LazySingletonOne {

    private static LazySingletonOne instence = null;

    private LazySingletonOne(){}

    public static LazySingletonOne getInstence(){
        if(null == instence){
            instence = new LazySingletonOne();
        }

        return instence;
    }
}

懒汉式单例模式是最基础的一种写法，但是如果我们在并发环境下去调用getInstance()的时候，可能会创建出多个instance，这样就违背了我们单例的初衷，所以我们对这个方法进行一个加锁机制，这样就能保证，每次调用时首先会获取锁资源，保证了实例的单一性。

public class LazySingletonTwo {
    private static LazySingletonTwo instance = null;

    private LazySingletonTwo(){}

    synchronized public static LazySingletonTwo getInstance(){
        if(null == instance){
            instance = new LazySingletonTwo();
        }
        return instance;
    }
}

代码做了简单的修改，引入了锁的机制，每次调用getInstance函数时，我们都会上一把锁，保证只有一个线程执行它，这个时候并发的问题就解决了。不过现在不管什么情况下都会上一把锁，代价较大。

2.DoubleCheck 懒汉式

public class LazyDoubleCheckSingleton {
    private static volatile LazyDoubleCheckSingleton instance = null;

    private LazyDoubleCheckSingleton(){}

    public static LazyDoubleCheckSingleton getInstance(){
        if(null == instance){
            synchronized (LazyDoubleCheckSingleton.class){
                if(null == instance){
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

此时极大地避免了锁的竞争，一旦对象实例化成功，后续的请求不会再获取锁。

3.静态内部类

public class StaticInnerClassSingleton {

    private StaticInnerClassSingleton(){}

    private static class InnerClass{
        private static StaticInnerClassSingleton instance =