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("这么麻烦 还是 饿汉式吧 怎么也就一句话都安全");    }}