Kotlin单例的几种写法

超、凢脫俗 2022-12-09 05:15 300阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70_pic_center]

# 1. 饿汉式单例 #

--------------------

Kotlin 语法层面就支持单例，即 object 关键字，相对于Java 单例的一坨模板代码简单得多：

object WorkSingleton

反编译后会发现，`object`实际是`一个`基于static的饿汉式的单例，有点是线程安全，缺点是不能实现懒加载：

public final class WorkSingleton { 
       public static final WorkSingleton INSTANCE;
    
       static { 
          WorkSingleton var0 = new WorkSingleton();
          INSTANCE = var0;
       }
    }

# 2. 懒汉式单例 #

--------------------

利用伴生对象 和 `by lazy` 也可以实现单例，可以实现懒汉式的线程安全单例

class WorkSingleton private constructor() { 
    
        companion object { 
            //LazyThreadSafetyMode.SYNCHRONIZED可以省略
            val INSTANCE1 by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {  WorkSingleton() }
    
        }
    }

非多线程环境下，可以 `mode = LazyThreadSafetyMode.NONE`，就是一个费线程安全单例，以提高性能

# 3. 带参数单例 #

--------------------

有时希望在单例初始化时传递参数，例如

Singleton.getInstance(context).doSome()

可以通过伴生对象的继承实现：

class WorkSingleton private constructor(context: Context) { 
        init { 
            // Init using context argument
        }
    
        companion object : SingletonHolder<WorkSingleton, Context>(::WorkSingleton)
    }
    
    
    open class SingletonHolder<out T : Any, in A>(creator: (A) -> T) { 
        private var creator: ((A) -> T)? = creator
        @Volatile
        private var instance: T? = null
    
        fun getInstance(arg: A): T { 
            val i = instance
            if (i != null) { 
                return i
            }
    
            return synchronized(this) { 
                val i2 = instance
                if (i2 != null) { 
                    i2
                } else { 
                    val created = creator!!(arg)
                    instance = created
                    creator = null
                    created
                }
            }
        }
    }

与Java 中双重校验锁的机制很像， `SingletonHolder` 类中如果已经初始化了直接返回，如果没有初始化进入 synchronized 代码块创建对象。

通过 Kotlin 将伴生对象作为子类实现了与静态继承相当的功能，所以我们将 SingletonHolder 作为单例类伴生对象的基类，便于在单例类上复用，凡是需要传递参数的单例模式，只需将单例类的伴生对象继承于 `SingletonHolder`，然后通过泛型指定单例类和参数类型即可：

class FileSingleton private constructor(path: String) { 
    
        companion object : SingletonHolder<FileSingleton, String>(::FileSingleton)
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpdGF2aXZh_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/9955f6cf272a4088bf1e24202db207ce.png