Асинхронность и сопрограммы

Асинхронность против параллельной обработки

Асинхронная и параллельная обработка — разные вещи.

Внутри сопрограммы последовательность обработки может быть приостановлена и возобновлена позже. Это позволяет использовать асинхронный неблокирующий код без обратных вызовов или промисов. Это асинхронная обработка, но всё, что связано с этой сопрограммой, может происходить в одном потоке.

Следующий код выполняет сетевой вызов с помощью Ktor. В основном потоке вызов инициируется и приостанавливается, в то время как другой процесс выполняет фактические сетевые операции. По завершении код возобновляется в основном потоке.

val client = HttpClient()
//Running in the main thread, start a `get` call
client.get<String>("https://example.com/some/rest/call")
//The get call will suspend and let other work happen in the main thread, and resume when the get call completes

Это отличается от параллельного кода, который должен выполняться в другом потоке. В зависимости от вашей цели и используемых библиотек, вам может никогда не понадобиться использовать несколько потоков.

Диспетчер для изменения потоков

Сопрограммы выполняются диспетчером, который определяет, в каком потоке будет выполняться сопрограмма. Есть несколько способов указать диспетчер или изменить его для сопрограммы, например:

suspend fun differentThread() = withContext(Dispatchers.Default){
    println("Different thread")
}

withContext принимает как аргумент диспетчер и блок кода, который будет выполняться в потоке, определённом диспетчером. Узнайте больше о контексте и диспетчерах сопрограмм.

Чтобы выполнить работу в другом потоке, укажите другой диспетчер и блок кода для выполнения. В целом, переключение диспетчеров и потоков работает аналогично JVM, но есть различия, связанные с замораживанием захваченных и возвращаемых данных.

Замороженные захваченные данные

Чтобы запустить код в другом потоке, вы передаёте functionBlock, который замораживается и затем выполняется в другом потоке.

fun <R> runOnDifferentThread(functionBlock: () -> R)

Вы вызовете эту функцию следующим образом:

runOnDifferentThread {
    //Code run in another thread
}

Как описано в обзоре асинхронности, состояние, используемое в Kotlin/Native между потоками, должно быть заморожено. Аргумент функции — это состояние, которое будет заморожено вместе со всем, что оно захватывает.

Функции сопрограмм, пересекающие потоки, используют тот же шаблон. Для возможности выполнения блоков функций в другом потоке, они замораживаются.

В следующем примере экземпляр класса данных dc будет захвачен блоком функции и заморожен при пересечении потоков. Инструкция println выведет true.

val dc = DataClass("Hello")
withContext(Dispatchers.Default) {
    println("${dc.isFrozen}")
}

При выполнении параллельного кода будьте внимательны к захваченному состоянию. Иногда очевидно, когда состояние будет захвачено, но не всегда. Например:

class SomeModel(val id:IdRec){
    suspend fun saveData() = withContext(Dispatchers.Default){
        saveToDb(id)
    }
}

Код внутри saveData выполняется в другом потоке. Это заморозит id, но так как id — это свойство родительского класса, то заморозится и родительский класс.

Замороженные возвращаемые данные

Данные, возвращаемые из другого потока, также замораживаются. Хотя рекомендуется возвращать неизменяемые данные, вы можете вернуть изменяемое состояние таким образом, что возвращаемое значение нельзя будет изменить.

val dc = withContext(Dispatchers.Default) {
    DataClass("Hello Again")
}

println("${dc.isFrozen}")

Это может быть проблемой, если изменяемое состояние изолировано в одном потоке, а для связи используются операции потоков сопрограмм. Если вы попытаетесь вернуть данные, которые сохраняют ссылку на изменяемое состояние, данные также будут заморожены по ассоциации.

Узнайте больше о состоянии, изолированном в потоке.

CoroutineWorker

CoroutinesWorker — это библиотека, опубликованная AutoDesk, которая реализует некоторые функции сопрограмм между потоками, используя однопоточную версию kotlinx.coroutines.

Для простых приостановленных функций это довольно хороший вариант, но он не поддерживает Flow и другие структуры.

Reaktive

Reaktive — это библиотека, похожая на Rx, которая реализует реактивные расширения для Kotlin Multiplatform. Она имеет некоторые расширения для сопрограмм, но в основном предназначена для RX и потоков.

Пользовательский процессор

Для более простых фоновых задач вы можете создать свой собственный процессор с обёртками вокруг особенностей платформы. Посмотрите простой пример.

Конкурентность платформы

В производстве вы также можете положиться на платформу для обработки конкурентности. Это может быть полезно, если общий код Kotlin будет использоваться для бизнес-логики или операций с данными, а не для архитектуры.

Для совместного использования состояния в iOS между потоками это состояние должно быть замороженным. Библиотеки конкурентности, упомянутые здесь, автоматически замораживают ваши данные. Вам редко потребуется делать это явно, если вообще когда-либо.

Если вы возвращаете данные на платформу iOS, которые должны быть совместно использованы между потоками, убедитесь, что данные заморожены до выхода за пределы iOS.

Kotlin имеет понятие замораживания только для платформ Kotlin/Native, включая iOS. Чтобы сделать freeze доступным в общем коде, вы можете создать реализации expect и actual для freeze, или использовать stately-common, которая предоставляет эту функциональность. В Kotlin/Native freeze заморозит ваше состояние, в то время как в JVM ничего не сделает.

Чтобы использовать stately-common, добавьте зависимость для набора исходных кодов commonMain в build.gradle(.kts):

val commonMain by getting {
    dependencies {
        implementation ("co.touchlab:stately-common:1.0.x")
    }
}

commonMain {
    dependencies {
        implementation 'co.touchlab:stately-common:1.0.x'
    }
}

Этот материал был подготовлен компанией Touchlab для публикации компанией JetBrains.