Kotlin thread save native lazy singleton с параметром

Ответ 1

У Kotlin есть эквивалент вашего Java-кода, но более безопасный. Проверка двойной блокировки не рекомендуется даже для Java. В Java вы должны использовать внутренний класс на статике, который также объясняется в Инициализация по требованию Идиома владельца.

Но эта Java. В Котлине просто используйте объект (необязательно ленивый делегат):

object Singletons {
    val something: OfMyType by lazy() { ... }

    val somethingLazyButLessSo: OtherType = OtherType()
    val moreLazies: FancyType by lazy() { ... }
}

Затем вы можете получить доступ к любой переменной-члену:

// Singletons is lazy instantiated now, then something is lazy instantiated after.  
val thing = Singletons.something // This is Doubly Lazy!

// this one is already loaded due to previous line
val eager = Singletons.somethingLazyButLessSo

// and Singletons.moreLazies isn't loaded yet until first access...

Kotlin намеренно избегает путаницы у людей с одиночными играми на Java. И избегает "неправильных версий" этого шаблона, которого много. Вместо этого он обеспечивает более простую и безопасную форму синглетонов.

Учитывая использование lazy(), если у вас есть другие члены, каждый будет индивидуально лениться. И поскольку они инициализируются в лямбда, переданной в lazy(), вы можете делать то, о чем вы просили, о настройке конструктора и для каждого свойства элемента.

В результате у вас есть ленивая загрузка объекта Singletons (при первом доступе экземпляра), а затем более лёгкая загрузка something (при первом доступе элемента) и полная гибкость в построении объекта.

См. также:

• lazy() функция
• Параметры режима ожидания с ленивым потоком
• Объявления объектов

В качестве дополнительной заметки просмотрите библиотеки типов объектов для Kotlin, которые аналогичны инъекции зависимостей, предоставив вам варианты с вариантами впрыска:

• Injekt - Я автор
• Kodein - Очень похоже и хорошо

Ответ 2

Объявление объекта именно для этой цели:

object Singleton {
    //singleton members
}

Он ленив и потокобезопасен, он инициализируется при первом вызове, так же как и статические инициализаторы Java.

Вы можете объявить object на верхнем уровне или внутри класса или другого объекта.

Для получения дополнительной информации о работе с object с Java см. этот ответ.

private object SingletonInit { //invisible outside the file
    lateinit var arg0: String
}

object Singleton {
    val arg0: String = SingletonInit.arg0
}

fun Singleton(arg0: String): Singleton { //mimic a constructor, if you want
    synchronized(SingletonInit) {
        SingletonInit.arg0 = arg0
        return Singleton
    }
}

Основной недостаток этого решения состоит в том, что для определения singleton требуется отдельный файл, чтобы скрыть object SingletonInit, и вы не можете ссылаться на Singleton непосредственно до его инициализации.

Также см. аналогичный вопрос о предоставлении аргументов для одноэлемента.

Ответ 3

Недавно я написал статью по этому вопросу. TL; DR Здесь решение я подошел к:

1) Создайте класс SingletonHolder. Вам нужно только написать его один раз:

open class SingletonHolder<out T, 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
            }
        }
    }
}

2) Используйте это в своих синглонах:

class MySingleton private constructor(arg: ArgumentType) {
    init {
        // Init using argument
    }

    companion object : SingletonHolder<MySingleton, ArgumentType>(::MySingleton)
}

Инициализация синглтона будет ленивой и потокобезопасной.