java设计模式：单例设计模式

package com.selfStudy;

/*
 * 单例设计模式：保证这个类内存的唯一性；
 * 
 * 请写一个延迟加载的单例设计模式
 * */
class HungrySingle{
    //饿在多线程中没有问题 ；可以放心用

    //静态final这样一加载就会创建这个HungrySingle对象，并且终生指向它
    private static final  HungrySingle hungrySingle = new HungrySingle();
    //私有化构造方法，使得只有在类内部才能创建
    private HungrySingle(){}
    //对外只提供一个获取这个单例的方法
    public static HungrySingle getInstance(){
        return hungrySingle;
    }
}

class LazySingle{
//  懒汉式；延迟加载、因为只有用到LazySingle时才会创建；
    //只可以静态不可以final 否则终身为空
    private static LazySingle lazySingle= null;
    //私有化构造方法，使得只有在类内部才能创建
    private LazySingle(){}
    //对外只提供一个获取这个单例的方法
    public static LazySingle getInstance(){
        if(lazySingle ==null)
            lazySingle = new LazySingle();
        return lazySingle;
    }
}
/*
 * 懒汉式在多线程中存在的问题：
 * public static LazySingle getInstance(){
        if(lazySingle ==null)
            ---->A;------>B;在此挂起了；当其醒来时，就不会在就会直接向下执行，这样就new了两个对象
            lazySingle = new LazySingle();
        return lazySingle;
    }
 * 
 * */
/*懒汉式解决多线程方式1：
 * 存在的缺点：
 *  效率太低了，原因：在函数上加同步，如果存在多个线程都调用它，那么就会出现多个判断锁，这样是
 *  很浪费时间的，
 */

class LazySingleSynchronizedOne{
    private static LazySingleSynchronizedOne lazySingle= null;

    private LazySingleSynchronizedOne(){}

    public static synchronized LazySingleSynchronizedOne getInstance(){
        if(lazySingle ==null)
            lazySingle = new LazySingleSynchronizedOne();
        return lazySingle;
    }
}
/*懒汉式解决多线程方式2：
 *  if(lazySingle ==null)
            lazySingle = new LazySingleSynchronizedOne();
    给这两句话加同步代码块；
    synchronized(该类的字节码对象){
        if(lazySingle ==null)
            lazySingle = new LazySingleSynchronizedOne();
    }
    这样做和第一种解决方式没有什么大区别；
    加入有三个线程A B C
    ---->C(3)
    if(lazySingle ==null)
            ----->B(2)
            synchronized(LazySingleSynchronizedTwo.class){
                if(lazySingle==null)
                    ---->A(1),
                    lazySingle = new LazySingleSynchronizedTwo();
            }
    当A醒来时候，就会直接new对象 此时B和C时进不了的，当A new完出去后，假如B进来了一判断不等于null，不new了；此时假如C醒了，
    一判断不等于null就不会在进入同步代码块中了；
 * 优点：
 *  效率太低了，原因：在函数上加同步，如果存在多个线程都调用它，那么就会出现多个判断锁，这样是
 *  很浪费时间的，
 */

class LazySingleSynchronizedTwo{
    private static LazySingleSynchronizedTwo lazySingle= null;

    private LazySingleSynchronizedTwo(){}

    public static LazySingleSynchronizedTwo getInstance(){
        if(lazySingle ==null){
            synchronized(LazySingleSynchronizedTwo.class){
                if(lazySingle==null)
                    lazySingle = new LazySingleSynchronizedTwo();
            }
        }

        return lazySingle;
    }
}
public class SingleModel {

    public static void main(String[] args) {
        System.out.println("这么麻烦 还是 饿汉式吧 怎么也就一句话都安全");

    }

}