1、单例模式：某个类只能有一个实例，这个实例必须自行创建，必须提供对外提供唯一调用它的方法
单例模式的作用应该是和同步锁一样，当我对这个类进行逻辑操作的时候，有且只有一个实例可以进行，而不是在同一时刻出现大量操作它的步骤
①：懒汉式，字面理解 懒--说明除非当前时刻必须要做的事情，是不会预先去做什么准备，那么放在单例模式中，则代表在类加载的时刻，我是不会去实例化当前类的对象的，只有调用了实例化的方法后才去做这件事情，见如下代码：
public class SingleTonClass{
private static SingleTonClass singleTonClass = null；
//私有化构造参数
private SingleTonClass（）{}
//对外提供一个实例化当前单例的方法
public static synchronize SingleTonClass getInstance（）{
if（singleTonClass == null）{
singleTonClass = new SingleTonClass（）;
}
return singleTonClass；
}
}
对static的一些解释，静态static这个关键字不可以修饰顶级类（顶级类就是一个.Java文件最外层的类名，被称为顶级类），只有内部类是可以用static来修饰
②：饿汉式，相对于懒汉式，它会去预加载，也就是说在类加载的时候，它就会创建单例模式的实例
public class SingleTon{
//私有化构造参数
private SingleTon（）{}
private SingleTon singleTon = new SingleTon（）；
//对外提供调用单例模式的方法
public Static SingleTon genInstance（）{
return singleTon；
}
}
③第三种方式，双重锁
//这个模式将同步内容下方到if内部，提高了执行的效率，不必每次获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
//这种模式中双重判断加同步的方式，比第一个例子中的效率大大提升，因为如果单层if判断，在服务器允许的情况下，
//假设有一百个线程，耗费的时间为100*（同步判断时间+if判断时间），而如果双重if判断，100的线程可以同时if判断，理论消耗的时间只有一个if判断的时间。
//所以如果面对高并发的情况，而且采用的是懒汉模式，最好的选择就是双重判断加同步的方式。
public class SingleTon{
private static SingleTon singleTon = null；
//私有化构造方法
private SingleTon（）{}
public static SingleTon genInstance（）{
if（singleTon == null）{
synchronize（SingleTon.class）{
if（singleTon==null）{
singleTon = newSingleTon（）；
}
}
}
return SingleTon；
}
}
