单例模式（饿汉式，懒汉式，双重检验锁）

单例模式（饿汉式，懒汉式，双重检验锁）

三步走：
1，构造私有化（保证对象的产生的个数）
2，单例类的内部提供这个唯一的对象（static）
3，单例类提供返回这个唯一对象的静态方法供外部使用

  //饿汉式
    public static class SingleHungry{
        //尽可能的满足目前，先把能拿到的都拿到
        private static SingleHungry singleHungry=new SingleHungry();
        private SingleHungry(){}
        public static SingleHungry getStringsingGeleTon(){
            return singleHungry;
        }
    }

懒汉式

public class SingleTonLazy {
    private static volatile SingleTonLazy singleTonLazy;
    static void SingleTonLazyren(){}
    public static  SingleTonLazy getStringlazyRen() {
    //这里会线程不安全；
        if(singleTonLazy==null){
            singleTonLazy = new SingleTonLazy();
        }
        return singleTonLazy;
    }
}

线程安全的懒汉式

public class SingleTonLazy {
    private static volatile SingleTonLazy singleTonLazy;
    static void SingleTonLazyren(){}
    public static  SingleTonLazy getStringlazyRen() {
        if(singleTonLazy==null){
            synchronized (SingleTonLazy.class) {//锁住整个类，线程就安全了
                if (singleTonLazy == null) {
                    singleTonLazy = new SingleTonLazy();
                }
            }
        }
        return singleTonLazy;
    }
}

双重检验锁

public static class Double_Check{
        private static volatile Double_Check double_check;
        //volatile保证可见性
        //（从主存中读到工作方法区在方法区改变的数字会刷新到主存中，在访问这个变量之前）
        //表示着线程本地内存无效，当一个线程修改共享
        // 变量后他会立即被更新到主内存中，其他线程读取共享变量时，会直接从主内存中读取。
        private Double_Check(){}
        static Double_Check getStringDoubleCheck(){
            if(double_check==null){
                synchronized (Double_Check.class){
                    if(double_check==null){
                        double_check=new Double_Check();
                    }
                }
            }
            return double_check; 
        }
    }
}

双重检验锁中的volatile还是有一个作用是： 可以保证return 的对象是完整的，不会被中断，不然返回可能是不完整的对象