美文网首页Android知识Android技术知识Android进阶之路
Java 设计模式DesignPattern之单例模式Singl

Java 设计模式DesignPattern之单例模式Singl

作者: 勇敢写信 | 来源:发表于2018-03-23 15:49 被阅读0次

    我的博客

    单例模式是我们经常用到的设计模式。
    优点:如果对象的数据量比较大,单例模式可以避免重复的创建对象,保证内存中只有一份实例
    缺点:不易被销毁,只有程序退出才会被销毁

    首先,看一下简单的步骤

    public class Singleton {
    
        /**
         * 私有静态实例,防止被引用。此处赋值null是为了实现延迟加载
         */
        private static Singleton singleton = null;
    
        /**
         * 私有构造方法,防止被实例化
         */
        private Singleton() {
    
        }
    
        /**
         * 公共、静态的方法,创建实例
         *
         * @return Singleton
         */
        public static Singleton getInstance() {
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
    
        }
    }
    

    如果考虑多线程的情况,就可能出现创建多个实例的问题了。例如现在又两个线程,线程A和线程B,如果线程A正在创建实例,线程B访问 if (singleton == null) 判断,就会再次进入new Singleton()这行代码,这就出现创建两次实例的情况。为了避免这种情况,我们可以使用同步锁synchronized关键字

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

    这样就保证不会出现多线程访问造成多实例的问题了。但是这里有性能问题:每次获取实例都需要获取锁,很耗费性能。其实我们只需要第一次实例化的时候用到锁。那好,我们改良一下代码。

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

    这样我们就保证了只对第一次实例化的情况使用了锁。但是,这里还有一个问题:由于指针重排序,造成实例还没有初始化就开始使用实例的情况。
    在这里,需要温习一下java的基础知识:、
    singleton = new Singleton()
    这行代码都进行了哪些操作

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

    上述伪代码中2和3可能重新排序,出现下面的情况

    memory = allocate();   //1:分配对象的内存空间
    instance = memory;     //3:设置instance指向刚分配的内存地址
                           //注意,此时对象还没有被初始化!
    ctorInstance(memory);  //2:初始化对象
    

    此时线程B就会访问一个没有初始化的对象,出现异常。为了解决上述情况,我们需要稍微修改一下代码即可:把instance 声明为volatile类型,就可以实现线程安全的延迟初始化。

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

    关于volatile的作用,只需要知道使用volatile上述伪代码中的指针重新排序将被禁止就行.

    上述代码已经是线程安全的单例模式了,基于volatile的双重检查锁定(DOUBLE_CHECK)的解决方案。但是代码过于复杂。接下来介绍一种最简单也是最安全的单例模式。

        /**
         * 获得单例
         *
         * @return
         */
        public static Singleton getInstance() {
            return InstanceHolder.INSTANCE;
        }
    
        /**
         * 单例持有器
         */
        private static final class InstanceHolder {
            private static final Singleton INSTANCE = new Singleton();
        }
    
        /**
         * 禁止构造
         */
        private Singleton() {
        }
    

    这种是基于类初始化的一种解决方案。JVM在类的初始化阶段(即在Class被加载后,且被线程使用之前),会执行类的初始化。在执行类的初始化期间,JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。基于这个特性,可以实现另一种线程安全的延迟初始化方案(这个方案被称之为Initialization On Demand Holder idiom)

    总结:
    延迟初始化降低了初始化类或创建实例的开销,但增加了访问被延迟初始化的字段的开销。在大多数时候,正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化,请使用上面介绍的基于volatile的延迟初始化的方案;如果确实需要对静态字段使用线程安全的延迟初始化,请使用上面介绍的基于类初始化的方案。

    相关文章

      网友评论

        本文标题:Java 设计模式DesignPattern之单例模式Singl

        本文链接:https://www.haomeiwen.com/subject/wlfxcftx.html