单例模式

什么是单例模式？单例模式就是只允许生成一个实例的类。

一般来说，被创建出的单例类的对象都是由单例类本身持有，然后也是由单例类本身来创建，也就是说单例类的构造器必须是私有的。

单例类主要用来解决全局类被频繁的创建和销毁，应用场景：上数据库连接驱动，数据库连接池等

懒汉模式

懒汉模式指在单例类加载时不进行实例初始化，当需要使用实例时才进行实例初始化，获取对象较慢，类加载较快

线程不安全

/**

* @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("我干活了！");
    }
}

总结：

懒汉模式是时间换空间，饿汉模式是空间换时间，
懒汉线程不安全，需要使用线程锁和双重检查实现线程安全，饿汉是线程安全的。