设计模式-单例模式（Singleton）

定义: Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

应用场景：比如建立目录或数据库连接都需要这样的单例。

实现思路：
1.私有的构造器，以防止外部new出多个实例
2.在内部提供一个单实例
3.向外部暴露一个获取该单实例的方法

4.同步控制，防止生成多个实例

实现单例模式常用的几种方式：饿汉式、懒汉式、懒汉双检索式、内部类实现式、枚举实现式等

一、饿汉式

1.饿汉式(线程安全)

class Singleton {	
	private static Singleton instance = new Singleton();

	private Singleton() {}

	public static Singleton getInstance() { 
		return instance;
	}
}

类被加载时就对instance进行实例化，单实例就被创建了。养兵千日用兵一时，不管以后用不用的着，先创建再说，以空间换时间。

优点：这种写法简单，类装载时完成实例化。避免了线程安全问题。

缺点：没达到懒加载效果。如果该实例一直没使用到，但它却一直占用内存空间。

2.饿汉式变体(线程安全)

class Singleton {	
	private static Singleton instance;

	static{
		instance = new Singleton();
	}
	
	private Singleton() {}

	public static Singleton getInstance() { 
		return instance;
	}
}

同上

二、懒汉式

1.懒汉式（线程安全）

class Singleton {	
	private static Singleton instance;

	private Singleton() {}

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

缺点：每次获取实例都要进行同步，其实一旦创建了实例，再获取时只需要返回而无需进行同步。所以效率低。

2.不安全的改进(线程不安全)

改进。改成同步代码块实现，缩小临界区。

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

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

但是出现了线程安全问题。

假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以这种方式是非线程安全的。

3.不安全的双检索方式(非线程安全)

继续改进。在同步时，再进行一次判空操作。这种方式叫做"双重检查锁"，可以简称"双检锁"。

public class Singleton {
     
    private static Singleton singleton;

    private Singleton() {}

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

这种方式好像能解决问题，但是实际上这样做依然无济于事。原因很多，指令的重排序，内存不可见等。

4.安全的双检索方式(线程安全)

最简单的解决上面双检索不安全的方式就是使用volatile。

public class Singleton {
    //用volatile修饰
    private static volatile Singleton singleton;

    private Singleton() {}

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

该版本的双检锁机制的实现使用关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量。

注意：在java1.4及以前版本中，很多JVM对于volatile关键字的实现的问题，会导致“双重检查加锁”的失败，因此“双重检查加锁”机制只能用在java5及以上的版本。

由于volatile关键字可能会屏蔽掉虚拟机中一些必要的代码优化，所以运行效率可能并不高。而且有其它解决方案，因此该实现版本并不推荐

关于使用双检索时不加volatile可能导致的线程不安全的分析，请参考

The "Double-Checked Locking is Broken" Declaration和对应的翻译可以不要再使用Double-Checked Locking了

三、内部类实现方式

public class Singleton {

    private Singleton() {}
    
    //内部类
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：延迟加载，线程安全，效率高。

四、枚举实现方式

public enum Singleton {
    INSTANCE;
}

借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。可能是因为枚举在JDK1.5中才添加，所以在实际项目开发中，很少见人这么写过。
优点：
系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
缺点：
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new，可能会给其他开发人员造成困扰，特别是看不到源码的时候。

参考博客：

《JAVA与模式》之单例模式

单例模式的线程安全问题：探索设计模式之六——单例模式