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

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

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对象。