单例模式（Singleton Pattern）

什么是单例模式：

确保一个类只有一个实例，并且提示一个全局访问点。

单例模式有什么用处：

很多场景下有一些对象我们只需要一个，比方说：线程池，缓存，驱动程序等等。实际上这些对象只能有一个实例，如果存在多个实例就会导致一些问题，例如程序的行为异常（线程池实例多了就不止是我们当初设想的比方说10个线程，而是10*n个线程了），资源使用过量（本地缓存实例多了，哪怕各个缓存实例间保持了同步，依旧会占用内存资源），结果不一致等等。

如何实现单例模式：

根据单例模式创建实例的时机不同又可分为饿汉模式和懒汉模式。

下面先看看饿汉模式

/**
 * 饿汉模式
 */
public class HungryObject {

    private static final HungryObject hungryObject = new HungryObject();

    private HungryObject(){

    }

    public static HungryObject getInstance(){
        return hungryObject;
    }
}

测试方法：

public static void main(String[] args) {
   HungryObject hungryObject1 =HungryObject.getInstance();
   HungryObject hungryObject2 =HungryObject.getInstance();
   System.out.println(hungryObject1 == hungryObject2);

}

运行结果为：true

说明测试方法中的hungryObject1和hungryObject2实际指向的是同一个实例。

由此看来，单例模式需要满足一下几个要求：

1.构造器不能对外公开，否则其他类都能够自由创建该类的对象。

2.既然其他类不能创建该类的实例对象，那么只能在该类内部完成创建的工作。既然不是该对象的方法，那么只能通过类的静态方法获取实例。

3.要保证获取到的实例是单例，就需要有一个类的静态成员变量来保存这个实例。

这3个条件是单例模式的最基本条件。

同样的，懒汉模式也必须满足这些条件：

public class LazyObject {

   private static volatile LazyObject lazyObject;
   private LazyObject() {}

   public static LazyObject getInstance() {
      if (lazyObject == null) {
         lazyObject = new LazyObject();
      }
      return lazyObject;
   }
}

测试方法同上一样，结果也是：true

那么就有人问了，2种方式都能完成单例模式的需求，那么怎么选择呢？

如何选择就是根据2种方式的不同之处来抉择，那么不同点是什么？细心的同学会发现，一开始我就已经提到了，根据单例模式创建实例的时机不同可分为饿汉模式和懒汉模式。

通过代码可以看出饿汉模式是在类加载的时候创建的对象；而懒汉模式是在应用程序第一次调用getInstance()方法时创建的对象。

值得一提的是，实际场景下，基本所有的应用程序都是多线程的，在多线程的情况下，由于饿汉模式是在类加载时候创建的对象，所以不管多少线程，都能确保是单例。

反观刚刚的懒汉模式的代码，在并发访问getInstance()方法的时候，就有可能会出现多个实例的情况，下面就来升级一下代码，保证线程安全：

public class MyObject {
   
   private static volatile MyObject myObject;
   private MyObject(){    }
   
   public static MyObject getInstance(){
      if(myObject == null){
         synchronized (MyObject.class) {
            if(myObject == null){
               myObject = new MyObject();
            }
         }
      }
      return myObject;
   }
}

在getInstance()方法中加入了同步锁，来保证并发情况下，各线程获取到的是同一实例。可是同步锁会造成性能的降低，那么问题有回到了最初，如何选择？？

饿汉模式在程序启动加载类时创建对象，创建就需要时间，对象保存在内存中，之后应用程序需要时可直接获取。因此，启动会花更多的时间，而获取对象时耗的时间会相对较少。但是如果一直不调用getInstance()方法，即一直不需要这个对象的话，就显得有些浪费内存空间了。也就是说这是一种以“空间换时间”的方式。

懒汉模式在程序第一次调用getInstance()方法时才创建对象，因此启动较快。可是在获取实例的时候，由于同步锁的存在，性能降低，花费的时间较多。也就是说这是一种“时间换空间”的方式。

到底如何取舍，还是看程序自身的要求。适合，即最好。