(一) 单例模式详解

单例模式适合于应用中频繁创建并且无状态的对象，比如配置文件。如果不采用单例模式的话，当对它进行更新操作时，需要同步其它所有存活的对象。白白浪费性能、内存，所以有必要使用单例模式来保证这个对象全局仅有一个实例。

单例模式 : 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
通常我们可以让一个全局变量使得一个对象被访问，但它不能阻止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例，这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

综上所述要想实现单例模式 大抵分两步
1、类构造方法私有化(private修饰) : 防止外部直接 new 生成对象
2、对外提供一个静态方法(static修饰) 让外部可以直接获取到该类唯一实例

常见的单例模式 大概有以下几种：
懒汉式：全局的单例实例在第一次被使用时构建。
饿汉式：全局的单例实例在类装载时构建。
注册式(容器): 类似springIoc容器
枚举类 : 有效防止 反射、序列化破坏
ThreadLocal : 每个线程 有属于自己的实例

懒汉式 :

1. 裸奔懒汉式
2. 同步懒汉式
3. 双重锁定懒汉式

裸奔懒汉式 :

public class GeneralSingleton {
    
    // 构造方法 私有化
    private GeneralSingleton() {}

    //声明私有 成员变量
    private static GeneralSingleton singleton;

    //公共获取实例方法
    public static GeneralSingleton getInstance() {
        if (singleton == null) {
            singleton = new GeneralSingleton();
        }
        return singleton;
    }
}

这种是最简单的单例模式，但是其中却存在线程安全问题，当多线程工作的时候，如果有多个线程同时运行到if (singleton == null)，都判断为null，那么两个线程就各自会创建一个实例——这样一来，就不是单例了。故此此种方法不推荐使用。

---

同步懒汉式 :

public class GeneralSingleton {
    
    // 构造方法 私有化
    private GeneralSingleton() {}

    //声明私有 成员变量
    private static GeneralSingleton singleton;

    // 新增 synchronized 关键字 让jvm保证任意时刻仅有一个线程执行该方法
    public synchronized static GeneralSingleton getInstance() {
        if (singleton == null) {
            singleton = new GeneralSingleton();
        }
        return singleton;
    }
}

加上synchronized关键字之后，getInstance()方法就会锁上了。这时如果有两个线程（T1、T2）同时执行到这个方法时，会有其中一个线程T1获得同步锁，得以继续执行，而另一个线程T2则需要等待，当第T1执行完毕getInstance之后（完成了null判断、对象创建、获得返回值之后），T2线程才会执行执行。——所以这段代码也就避免了因为多线程导致产生多个实例的情况。
但是这种写法也有一个问题：方法加锁粒度太大，会对程序的执行效率造成很严重负面影响。我们之所以加 synchronized 是为了防止多线程情况下，对象被实例化多次，那么我们可以在 if (singleton == null) 内部进行加锁 这样整体性能就不再有影响了。

---

双重检查锁懒汉式 :

public class GeneralSingleton {
    
    // 构造方法 私有化
    private GeneralSingleton() {}

    //声明私有 成员变量
    private static GeneralSingleton singleton;

    //双重检查锁
    public static GeneralSingleton getInstance3() {
        if (singleton == null) {
            synchronized(GeneralSingleton.class) {
                if (singleton == null) {
                    singleton = new GeneralSingleton();
                }
            }
        }
        return singleton;
    }
}

注意其中有两次if (singleton == null)的判断，这个叫做『双重检查 Double-Check』。
第一个if (singleton == null)，其实是为了解决 方法锁导致的效率问题，只有singleton为null的时候，才进入synchronized的代码段——这样就减小了上锁的几率。
第二个if (singleton == null)，则是为了防止多个线程都进入 if 判断后 多次new 的情况。

这段代码虽然看起来已经完美无瑕了但是还是有小概率出现问题的。
JVM 在执行创建实例操作的时候，其实是分了好几步去进行的，也就是说创建一个新的对象并非是原子性操作。

大概要经过三步。

1. 分配内存
2. 初始化构造器
3. 将对象内存地址指向变量

JVM 有时会针对字节码进行调优(指令重排序)，而其中的一项调优便是调整指令的执行顺序），如果2和3步骤相反了，先将内存地址赋给对象引用 然后再进行对象初始化构造器。这时如果在对象初始化构造器完成之前，其他线程使用了获取到的singleton对象，就会产生莫名的错误。
解决方法是在 private static GeneralSingleton singleton 声明处加上 volatile 关键字
标识该对象 禁止JVM对其指令重排序 并且强行保证线程中对该变量所做的任何写入操作对其他线程都是即时可见的。

---

饿汉式 :

1. 简单饿汉式
2. 静态内部类饿汉式

简单饿汉式 :

public class Singleton {

    private Singleton(){}
    // 
    private static Singleton singleton = new Singleton();
    
    public static Singleton getInstance() {
        return singleton;
    }
}

对于一个饿汉式单例的写法来说，它基本上已经足够了。所以它的缺点也就只是饿汉式单例本身的缺点所在了——由于对象的初始化是在类加载时进行的，很有可能初始化太早，造成资源的浪费。而且如果初始化动作需要依赖一些其他数据，那么也就很难保证其他数据会在它初始化之前准备好。

那么什么时候会触发类加载呢？大概会有以下几种情况。

1. new 这个对象时
2. 访问 这个对象静态域时
3. 子类被加载时，如果父类还没被加载，就先加载父类
4. 使用反射创建它的实例时

---

静态内部类饿汉式 :

public class Singleton {

    private static class SingletonHolder {

        private static final Singleton INSTANCE = new Singleton();

    }

    private Singleton (){
	if( SingletonHolder.INSTANCE != null) {
		throw new Exception( "防止反射 破坏唯一单例" );
    }
}

    public static final Singleton getInstance() {

        return SingletonHolder.INSTANCE;

    }

}

这种写法巧妙之处在于：
对于静态内部类SingletonHolder，它是一个饿汉式的单例实现 保证了全局唯一单例。
又由于 SingletonHolder 是一个静态内部类，所以只有当外部类Singleton的getInstance()方法被调用时才进行内部类的加载。
故此 它利用了ClassLoader来保证了同步，同时又能让开发者控制类加载的时机。从内部看是一个饿汉式的单例，但是从外部看来，又的确是懒汉式的实现。

注册式(容器) :

/**
 * 注册容器 单例 (简易版)
 */
public class ContainerSingleton {

    private static final Map<String, Object> MAP = new ConcurrentHashMap<>(  );

    private ContainerSingleton(){}

    public static synchronized Object getInstance(String className) throws Exception {
        if(!MAP.containsKey( className )){
            Class<?> aClass = Class.forName( className );
            Object o = aClass.newInstance();
            MAP.put(className, o);
            return o;
        }
        return MAP.get( className );
    }

}

枚举法 :

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;
    }
}

ThreadLocal 线程单例 :

/**
 * 为每个线程分配 独自的单例对象
 */
public class ThreadLocalSingleton {

    private ThreadLocalSingleton(){}

    private static final ThreadLocal<ThreadLocalSingleton> INSTANCE = new ThreadLocal<ThreadLocalSingleton>(){
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };

    public static Object getInstance(){
        return INSTANCE.get();
    }
}