学习笔记
场景：
一般，我们在写程序或者开发系统的时候，会有这样的需求：有些类只需要在整个系统中只能出现一个类的实例(避免了一个全局使用的类频繁地创建与销毁)；比如一个全局配置信息类、或者一个Factory类，或是一个主控类，等等。这个时候就需要用到单例的设计模式
单例模式特点：
1、实例是全局的(因为这个原因，所以要考虑到多线程的共享全局资源的问题；因为是全局性的实例，所以，在多线程情况下，所有的全局共享的东西都会变得非常的危险)
2、只有一个实例，且只能这个类自己创建对象，并提供一个访问它的全局访问点
3、私有构造器
单例模式： 主要目的是想在整个系统中只能出现一个类的实例，避免了一个全局使用的类频繁地创建与销毁；比如你的软件的全局配置信息，或者是一个Factory，或是一个主控类，等等
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
优点：
1、Lazy加载初始化、实现延时加载
缺点：
1、线程不安全(多线程的情况下，可能会有多个进程同时通过 (singleton== null)的条件检查，于是，多个实例就创建出来，并且很可能造成内存泄露问题)
综上所述，不推荐在实际开发中使用懒汉式
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
另一种写法：
public class Singleton {
private static Singleton instance = null;
private Singleton (){}
public static Singleton getInstance() {
synchronized(Singleton.class){
if (instance == null) {
instance = new Singleton();
}
}
return instance;
}
}
优点：
1、Lazy加载初始化、实现延时加载
2、线程安全缺点：
1、虽然线程安全，但是仍然创建了很多实例(创建很多实例与单例的思想相违背的；虽然我们的synchronized方法会帮助我们同步所有的线程，让我们并行线程变成串行的一个一个去new，那不还是一样的吗？同样会出现很多实例。注意理解这里会创建很多实例。注意，创建对象的动作只有一次，后面的动作全是读取那个成员变量，这些读取的动作不需要线程同步啊。这样的作法感觉非常极端啊，为了一个初始化的创建动作，居然让我们达上了所有的读操作，严重影响后续的性能啊！)
2、效率很低，99% 情况下不需要同步综上所述，多线程下，对性能和内存要求高的情况下，不推荐使用此模式
public class Singleton {
/**
* 注意此处使用的关键字 volatile，
* 被volatile修饰的变量的值，将不会被本地线程缓存，
* 所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。
*/
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
优点：
1、Lazy加载初始化、实现延时加载
2、线程安全
3、使用了关键字volatile综上所述，多线程下，对性能和内存要求高，推荐使用此模式
使用 volatile 有两个功用：
1）这个变量不会在多个线程中存在复本，直接从内存读取。
2）这个关键字会禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。
但是，这个事情仅在Java 1.5版后有用，1.5版之前用这个变量也有问题，因为老版本的Java的内存模型是有缺陷的。
public class Singleton {
// volatile可以换成final
private volatile static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
优点：
1、线程安全(基于 classloader 机制避免了多线程的同步问题)
2、因为单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，所以创建实例本身是线程安全的缺点：
1、没有实现延时加载
2、但是，这种玩法的最大问题是——当这个类被加载的时候，new Singleton() 这句话就会被执行，就算是getInstance()没有被调用，类也被初始化了。
于是，这个可能会与我们想要的行为不一样，比如，我的类的构造函数中，有一些事可能需要依赖于别的类干的一些事（比如某个配置文件，或是某个被其它类创建的资源），我们希望他能在我第一次getInstance()时才被真正的创建。这样，我们可以控制真正的类创建的时刻，而不是把类的创建委托给了类装载器综上所述，推荐使用
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
优点：
1、线程安全
2、Lazy加载初始化、实现延时加载描述：
这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 4 种方式(饿汉模式)就显得很合理。上面这种方式，仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它只有在getInstance()被调用时才会真正创建；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。
综上所述，1.6版是老版《Effective Java》中推荐的方式
public enum Singleton {
INSTANCE;
public void method() {
}
}
优点：
1、线程安全
描述：
这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
不能通过 reflection attack 来调用私有构造方法。上面这种方式，仍然使用JVM本身机制保证了线程安全问题；由于 SingletonHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它只有在getInstance()被调用时才会真正创建；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。
综上所述，这也是新版的《Effective Java》中推荐的模式
public class SingletonManager {
private static Map<String, Object> objMap = new HashMap<String,Object>();
private Singleton() {}
public static void registerService(String key, Objectinstance) {
if (!objMap.containsKey(key) ) {
objMap.put(key, instance);
}
}
public static Object getService(String key) {
return objMap.get(key);
}
}
描述：
这种事用SingletonManager 将多种单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。
单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举
经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 4 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 3 种双检锁方式
