vlambda博客
学习文章列表

面试官:请你手写一个单例模式

点击蓝色“Java学习指南 关注我 ,

加个“星标,每天阅读Java干货文章



说实话,看到这个问题,我心里还是有点窃喜的~ 单例模式?不好意思,设计模式我只会单例,哈哈哈,看我一顿操作:

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

感觉很easy啊,先是构造器私有化,防止外部创建实例,然后提供一个静态的方法,当实例不存在时,创建一个实例返回。但是我仔细一看,有问题。如果两个线程同时运行到if (singleton == null)那不就创建两个实例返回了吗?这可咋整?我灵机一动,想到了之前看到过的饿汉模式:

public class Singleton {
    private static Singleton singleton = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return singleton;
    }
}

是不是解决了线程不安全的问题?完美~

那么回到问题本身,如果预先创建对象的方式比较消耗系统资源,会拖延程序启动的速度。我如何在不预先创建对象的情况下设计一个单例模式呢?我们直接想到的方法是加一个synchronized关键字:

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这可以说是很粗暴了,直接在静态方法上加synchronized,所有调用到这个方法的程序都需要排队一个一个执行,效率可以说是很低的,那么怎么提高效率呢?我们可以这么做:

public class Singleton {
    private static Singleton singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这是双重加锁机制,先判断对象是否存在,如果不存在,加锁后再次判断,如果还不存在,则创建新的对象。这样我们是不是就完全解决了线程安全问题?其实不是的,还有一个地方更需要注意。这涉及到JVM编译时的指令重排机制,什么是指令重排?singleton = new Singleton(),会被编译器编译成如下JVM指令:

memory = allocate();    //1:分配对象的内存空间 
ctorInstance(memory);  //2:初始化对象 
instance = memory;     //3:设置instance指向刚分配的内存地址

在实际运行的时候有可能顺序是这样的:

memory = allocate();    //1:分配对象的内存空间 
instance = memory;     //3:设置instance指向刚分配的内存地址 
ctorInstance(memory);  //2:初始化对象 

当线程A执行完1,3,时,instance对象还未完成初始化,但已经不再指向null。此时如果线程B抢占到CPU资源,执行  if(singleton == null)的结果会是false,从而返回一个没有初始化完成的singleton对象,也就是说获得了一个为null的对象。怎么避免这一情况呢?我们可以使用volatile关键字,禁止指令重排,线程安全的单例模式如下:

public class Singleton {
    private static volatile Singleton singleton = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized(Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

除了饿汉和懒汉模式之外还有两种创建单例的方法,第一种是静态内部类的方式,这也是一种延迟加载的方式去创建单例对象,不会造成系统资源的浪费,而且这种方式创建非常简单,线程安全,所以我比较推荐:

public class Singleton {  
    private static class SingletonHolder {  
     private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

第二种是枚举类,但是这种方式在平常开发的时候用的少,可读性不好,一般很少使用:

public enum Singleton  {
    INSTANCE      
    //可以省略此方法,通过Singleton.INSTANCE进行操作
    public static Singleton get Instance() {
        return Singleton.INSTANCE;
    }
}



END

如有收获,请划至底部,点击“在看”,谢

每天一个Java学习小技巧