单例模式（饿汉式单例 VS 懒汉式单例）

所谓的单例模式就是保证某个类在程序中只有一个对象

一、如何控制只产生一个对象？

1.构造方法私有化（保证对象的产生个数）

        创建类的对象，要通过构造方法产生对象

       构造方法若是public权限，对于类的外部，可以随意创建对象，无法控制对象个数

      构造方法私有化，这样类的外部就彻底无法产生对象，一个对象都没有。

2.单例类的内部提供这个唯一的对象（static）

        构造方法私有化后，对于类的外部而言就一个对象都没有了。因此要在这个类的内部构造出这个唯一的对象，只调用一次构造方法即可（这个单例对象不能是类的成员属性，因为成员变量必须通过对象来访问，但是类的外部根本无法产生对象，（矛盾），因此这个对象必须使用static关键字修饰，静态变量，不依赖类的对象）

3.单例类提供返回这个唯一对象的静态方法供外部使用

二、饿汉式单例

饿汉式单例模式是天然的线程安全的。类加载时就创建了这个唯一的对象！！！

/**
 * 饿汉式单例(类加载就产生这个唯一的对象，也不管外部是否调用该对象)。饥不择食，这个类一加载就把惟一的这个对象产生了，
 * 我也不管外部到底用不用这个对象，只要这个类加载到JVM，唯一对象就会产生
 **/
public class SingleTon {
    // 惟一的这一个对象
    private static SingleTon singleTon = new SingleTon();
    private SingleTon() {}
    // 调用此方法时，singleTon对象已经产生过了，多线程场景下取回的是同一个单例对象
    public static SingleTon getSingleton() {
        return singleTon;
    }
}

三、懒汉式单例

懒汉式单例：只有第一次调用getSingleTon（），表示外部需要获取这个单例对象时才产生对象

public class LazySingleTon {
    private static LazySingleTon singleTon ;
    private LazySingleTon(){}
    
    public LazySingleTon getSingleTon(){
        if (singleTon == null){
            singleTon = new LazySingleTon();
        }
        return singleTon;
    }
}

多线程场景下会产生线程安全问题（不能确保只有一个对象产生） 

在这个场景下，三个线程并发调用get方法，此时三个 线程看到的singleTon 都为null，因此，每个线程都创建了一个对象！！

四、解决懒汉式单例的线程安全问题

1.静态方法上加锁

    public synchronized static LazySingleTon getSingleTon(){
        if (singleTon == null){
            singleTon = new LazySingleTon();
        }
        return singleTon;
    }

在方法上上锁，表示同一时间只有一个线程能进入此方法（其他线程想要进入此方法都等待获取锁成功的线程释放锁）。此时，getSingleTon（）的内部都是单线程操作（锁的粒度太粗）。

2.double-check（双重加锁）

    private volatile static LazySingleTon singleTon ;
    private LazySingleTon(){}
 
    public  static LazySingleTon getSingleTon(){
        if (singleTon == null){
            synchronized (LazySingleTon.class){
                if (singleTon == null){
                    singleTon = new LazySingleTon();
                }
            }
        }
        return singleTon;
    }

volatile的作用：内存屏障，可见性

此时有t1,t2,t3三个线程，t1首先获取到了锁，开始执行new操作，虽然还没完全结束，但此时的singleTon != null，对于刚开始执行代码的t2,t3来说，它们看到singleTon ！= null 直接返回了，但是返回后的单例对象是一个尚未完全初始化的对象

此时采用volatile关键字修饰单例对象，new操作有着一堵墙，其它线程要能执行到return语句，JVM一定保证了new操作完全结束了，之后才会执行return语句。

 double-check:防止其他线程恢复执行后多次创建单例对象

当t1先进入同步代码块后，t2,t3卡在获取所得位置，

t1产生对象后释放锁，

t2,t3还是从获取锁的位置继续执行，在他们的工作内存中，singleTon == null 

t2,t3就会再次new对象。