单例模式，Singleton Pattern,创建型。
一个单一的类，该类创建自己的对象，同时保证只有一个对象被创建。
提供访问其唯一的对象的方式，可直接访问，不需要实例化该类的对象。
关键代码：构造函数是私有的。
大部分时候，都把类的构造器定义为public访问权限，允许任何类自由的创建该类的对象。但在某些时候，允许其他类自由的创建该类的对象没有任何意义，还可能导致系统性能下降（因为频繁的创建对象，回收对象带来的系统开销问题）。例如，一个系统只有一个窗口管理器。
总之，在一些特殊场景下，要求不允许自由创建该类的对象，而只允许为该类创建一个对象，避免其他类自由创建该类的实例，应该把该类的构造器，使用private修饰，从而把该类的所有构造器隐藏起来。
根据封装型的原则：一旦把类的构造器隐藏起来，就需要提供一个public方法作为这个类的访问点，用于创建这个类的对象，且这个方法必须是static修饰（因为调用这个方法之前还不存在对象，因此调用这个方法不可能是对象，只能是类）；
五种单例模式：
懒汉式
线程不安全：
class Singleton { //使用一个变量来缓存曾经创建的实例 private static Singleton instance; //将构造器使用private修饰，隐藏该构造器 private Singleton(){} //提供一个静态方法，用于返回Singleton实例 //该方法可以加入自定义的控制，保证只产生一个Singleton对象 public static Singleton getInstance() { //如果instance为null，表明还不曾创建Singleton对象 //如果instance不为null，则表明已经创建了Singleton对象，将不会执行该方法 if (instance == null) { //创建一个Singleton对象，并将其缓存起来 instance = new Singleton(); } return instance; } } public class TestSingleton { public static void main(String[] args) { //创建Singleton对象不能通过构造器，只能通过getInstance方法 Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getInstance(); //将输出true System.out.println(s1 == s2); } }
这种写法lazy loading很明显，但是致命的是在多线程不能正常工作。
线程安全：
class Singleton{ private static Singleton instance; private Singleton(){} public static synchronized Singleton getInstance(){ if(instance==null){ instance = new Singleton(); } return instance; } }
这种写法能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是，每次调用getInstance方式时，都要去判断锁，效率很低，99%情况下不需要同步
饿汉式
class Single { private static Singleton instance = new Singleton(); private Singleton(){} public static Singleton getInstance(){ return instance; } }
这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。
双重锁校验
class Single { private volatile static Singleton instance; private Singleton(){} public static Singleton getInstance (){ if(instance == null){ synchronized(Singleton.class){ if(instance == null) { instance = new Singleton(); } } } return instance; } }
在JDK1.5之后，双重检查锁定才能够正常达到单例效果
枚举
public enum Singleton{ INSTANCE; public void whateverMethod(){ System.out.println("something"); } }
这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏。
静态内部类
class Singleton{ private Singleton(){} private static class SingletonHolder{ private static final Singleton instance = new Singleton(); } public static final Singleton getInstance(){ return SingletonHoldler.instance; } }
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,但Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显式装载SingletonHolder类，从而实例化instance。
各种方法各有利弊，斟酌使用。
推荐阅读：
http://www.blogjava.net/kenzhh/archive/2016/03/28/357824.html
https://blog.csdn.net/chenchaofuck1/article/details/51702129
https://blog.csdn.net/lzm18064126848/article/details/50074887
