单例模式
什么是单例模式？单例模式就是只允许生成一个实例的类。
一般来说，被创建出的单例类的对象都是由单例类本身持有，然后也是由单例类本身来创建，也就是说单例类的构造器必须是私有的。
单例类主要用来解决全局类被频繁的创建和销毁，应用场景：上数据库连接驱动，数据库连接池等
懒汉模式
懒汉模式指在单例类加载时不进行实例初始化，当需要使用实例时才进行实例初始化，获取对象较慢，类加载较快
线程不安全
/**
* @Auther: Lee
* @Date: 2018/6/11 10:26
* @Description: 懒汉模式的单例类 线程不安全
*/
public class LazyDemo {
private LazyDemo() {
System.out.println("你开始了？");
}
public static LazyDemo lazyDemo = null;
public static LazyDemo getInstance() {
//因为只能创建一个实例变量所以需要判断静态引用变量是否为null
//当多个线程同时进行到这个步骤，判定都为null，则都会生成新的实例
if (lazyDemo == null){
lazyDemo = new LazyDemo();
}
return lazyDemo;
}
}
以上就实现了一个简单的单例类，但是上面这种方式在多线程环境下可能会出现线程不安全的情况，
比如:在判断if (lazyDemo == null)处，如果多个线程同时执行完这个判断，就是线程A执行完这个判断要进行下一步时，跳到了另外的线程，这个时候另外的线程还是判断引用的是null，那么这些线程都会执行下一步的生成实例代码，并将应用变量指向生成的实例地址。这样的话这个引用变量引用的就不止一个示例变量了。
线程安全（synchronized关键字）
解决这个问题就需要用到线程同步关键字synchronized；给getInstance方法加锁，
/**
* @Auther: Lee
* @Date: 2018/6/11 11:41
* @Description: 方法上加锁的单例类
*/
public class LazyLockDemo {
private LazyLockDemo() {
System.out.println("我开始了老哥！");
}
public static LazyLockDemo LazyLockDemo = null;
//这种方式解决了线程的问题，但是每次执行getInstance都需要获得锁，其他的线程等待 类似串行执行性能不好
public static synchronized LazyLockDemo getInstance(){
if (LazyLockDemo==null){
LazyLockDemo = new LazyLockDemo();
}
return LazyLockDemo;
}
}
上面这种方式对获取对象的整个方法加锁，效率较低
双重检查锁
那么可以将锁的范围缩小，仅仅在new新的对象那里使用同步。
/**
* @Auther: Lee
* @Date: 2018/6/11 11:49
* @Description: 双重检查锁，
*/
public class LazyDoubleLockDemo {
private LazyDoubleLockDemo() {
System.out.println("我开始了老哥！");
}
public static volatile LazyDoubleLockDemo lazyDoubleLockDemo = null;
public static LazyDoubleLockDemo getInstance(){
if (lazyDoubleLockDemo == null){
// 在使用构造方法生成实例时获得锁，获得锁之后再进行一次判断是否有实例
// 这种方式是减少加锁的范围，由于syn关键字是可重入锁，所以两次加锁性能消耗并不会太多
// 这种方式在语句转化成计算机指令时，还是会出先线程不安全问题，
synchronized (LazyDoubleLockDemo.class){
if (lazyDoubleLockDemo ==null){
lazyDoubleLockDemo = new LazyDoubleLockDemo();
}
}
}
return lazyDoubleLockDemo;
}
}
可以看到，上面静态引用变量添加了volatile修饰符修饰，
因为，这里会涉及到一个指令重排序问题。
instance = new Singleton2(); 其实可以分为下面的步骤：
1.申请一块内存空间；
2.在这块空间里实例化对象；
3.instance的引用指向这块空间地址；
指令重排序存在的问题是：
对于以上步骤，指令重排序很有可能不是按上面123步骤依次执行的。
比如，先执行1申请一块内存空间，然后执行3步骤，instance的引用去指向刚刚申请的内存空间地址，
那么，当它再去执行2步骤，判断instance时，由于instance已经指向了某一地址，它就不会再为null了，
因此，也就不会实例化对象了。这就是所谓的指令重排序安全问题。所以，我们需要在创建引用变量时加上volatile关键字，因为volatile可以禁止指令重排序。
静态内部类
除了上面两种方式可以解决线程安全问题外，还有一种静态内部类的方式
/**
* @Auther: Lee
* @Date: 2018/6/11 11:57
* @Description: 静态内部类 应该还是饿汉
*/
public class LazyInnerClassDemo {
private LazyInnerClassDemo(){
System.out.println("我开始了老哥！");
}
private static class InnerClass{
private static final LazyInnerClassDemo LAZY_DOUBLE_LOCK_DEMO = new LazyInnerClassDemo();
}
public static LazyInnerClassDemo getInstance(){
return InnerClass.LAZY_DOUBLE_LOCK_DEMO;
}
}
饿汉模式
除了上面几种懒汉模式的实现外，还有饿汉模式，饿汉模式指的是当加载类时就初始化实例，类加载较慢，获取对象较快，与懒汉模式相比，饿汉模式是线程安全的
/**
* @Auther: Lee
* @Date: 2018/6/11 14:40
* @Description: 饿汉式单例模式 类加载时就保存一个实例对象
*/
public class HungerDemo {
private HungerDemo() {
System.out.println("我好了，你呢？");
}
private static final HungerDemo HUNGER_DEMO = new HungerDemo();
public static HungerDemo getInstance() {
return HUNGER_DEMO;
}
}
枚举实现
还有推荐使用的一种：枚举实现的单例类， 线程安全，速度很快
/**
* @Auther: Lee
* @Date: 2018/6/12 14:40
* @Description: 使用枚举实现单例
*/
public enum EnumDemo {
INSTANCE;
EnumDemo(){
System.out.println("我好了！");
}
public void doSomething(){
System.out.println("我干活了！");
}
}
总结：
懒汉模式是时间换空间，饿汉模式是空间换时间，
懒汉线程不安全，需要使用线程锁和双重检查实现线程安全，饿汉是线程安全的。
