Основы сопроцедур

Ваша первая сопроцедура

Сопроцедура — это экземпляр приостанавливаемого вычисления. Она концептуально похожа на поток в том смысле, что она принимает блок кода для выполнения в параллели с остальным кодом. Однако сопроцедура не привязана к какому-либо конкретному потоку. Она может приостановить своё выполнение в одном потоке и возобновить в другом.

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

Запустите следующий код, чтобы получить свою первую работающую сопроцедуру:

import kotlinx.coroutines.*

//sampleStart
fun main() = runBlocking { // this: CoroutineScope
    launch { // launch a new coroutine and continue
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
        println("World!") // print after delay
    }
    println("Hello") // main coroutine continues while a previous one is delayed
}
//sampleEnd

Вы увидите следующий результат:

Hello
World!

Давайте разберём, что делает этот код.

launch — это строитель сопроцедур. Он запускает новую сопроцедуру параллельно с остальным кодом, который продолжает работать независимо. Именно поэтому Hello было напечатано первым.

delay — это специальная приостанавливающая функция. Она приостанавливает сопроцедуру на определённое время. Приостановление сопроцедуры не блокирует базовый поток, но позволяет другим сопроцедурам выполняться и использовать базовый поток для своего кода.

runBlocking также является строителем сопроцедур, который связывает мир без сопроцедур обычной fun main() и код с сопроцедурами внутри runBlocking { ... } фигурных скобок. Это выделяется в IDE подсказкой this: CoroutineScope сразу после runBlocking открывающей фигурной скобки.

Если вы удалите или забудете runBlocking в этом коде, вы получите ошибку в вызове launch, так как launch объявлен только в CoroutineScope:

Unresolved reference: launch

Название runBlocking означает, что поток, который его выполняет (в данном случае — главный поток), блокируется на всё время вызова, пока все сопроцедуры внутри runBlocking { ... } не завершат своё выполнение. Вы часто увидите runBlocking используемым таким образом на самом верхнем уровне приложения и довольно редко внутри реального кода, так как потоки являются дорогостоящими ресурсами, и их блокировка неэффективна и часто нежелательна.

Рефакторинг: выделение функции

Давайте выделим блок кода внутри launch { ... } в отдельную функцию. При выполнении рефакторинга "Выделить функцию" на этом коде, вы получите новую функцию с модификатором suspend. Это ваша первая приостанавливающая функция. Приостанавливающие функции могут использоваться внутри сопроцедур так же, как и обычные функции, но их дополнительная особенность заключается в том, что они, в свою очередь, могут использовать другие приостанавливающие функции (например, delay в этом примере), чтобы приостановить выполнение сопроцедуры.

import kotlinx.coroutines.*

//sampleStart
fun main() = runBlocking { // this: CoroutineScope
    launch { doWorld() }
    println("Hello")
}

// this is your first suspending function
suspend fun doWorld() {
    delay(1000L)
    println("World!")
}
//sampleEnd

Строитель Scope

Помимо scope сопроцедуры, предоставляемого различными билдерами, можно объявить свой собственный scope, используя coroutineScope билдер. Он создаёт scope сопроцедуры и не завершается, пока не завершат все запущенные дочерние сопроцедуры.

runBlocking и coroutineScope билдеры могут выглядеть похожими, потому что оба ожидают завершения своего тела и всех своих дочерних элементов. Главное различие заключается в том, что метод runBlocking блокирует текущий поток для ожидания, в то время как coroutineScope просто приостанавливает, освобождая базовый поток для других задач. Из-за этого различия runBlocking является обычной функцией, а coroutineScope — приостанавливающей.

Вы можете использовать coroutineScope из любой приостанавливающей функции. Например, вы можете перенести одновременную печать Hello и World в функцию suspend fun doWorld().

import kotlinx.coroutines.*

//sampleStart
fun main() = runBlocking {
    doWorld()
}

suspend fun doWorld() = coroutineScope {  // this: CoroutineScope
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello")
}
//sampleEnd

Этот код также выведет:

Hello
World!

Строитель Scope и параллельность

Блок coroutineScope можно использовать внутри любой приостанавливающей функции для выполнения нескольких параллельных операций. Давайте запустим две параллельные сопроцедуры внутри doWorld приостанавливающей функции:

import kotlinx.coroutines.*

//sampleStart
// Sequentially executes doWorld followed by "Done"
fun main() = runBlocking {
    doWorld()
    println("Done")
}

// Concurrently executes both sections
suspend fun doWorld() = coroutineScope { // this: CoroutineScope
    launch {
        delay(2000L)
        println("World 2")
    }
    launch {
        delay(1000L)
        println("World 1")
    }
    println("Hello")
}
//sampleEnd

Оба фрагмента кода внутри launch { ... } блоков выполняются параллельно, с World 1 напечатанным первым, через секунду после старта, и World 2 напечатанным следующим, через две секунды от старта. coroutineScope в doWorld завершается только после завершения обоих, поэтому doWorld возвращается и позволяет напечатать строку Done только после этого:

Hello
World 1
World 2
Done

Явное задание

Блок launch сопроцедуры возвращает объект Job, который является дескриптором запущенной сопроцедуры и может использоваться для явного ожидания её завершения. Например, вы можете дождаться завершения дочерней сопроцедуры, а затем напечатать строку "Готово":

import kotlinx.coroutines.*

fun main() = runBlocking {
//sampleStart
    val job = launch { // launch a new coroutine and keep a reference to its Job
        delay(1000L)
        println("World!")
    }
    println("Hello")
    job.join() // wait until child coroutine completes
    println("Done") 
//sampleEnd    
}

Этот код выводит:

Hello
World!
Done

Корутины — лёгковесные

Корутины потребляют меньше ресурсов, чем потоки JVM. Код, который исчерпывает доступную память JVM при использовании потоков, можно выразить с помощью корутин, не столкнувшись с ограничениями ресурсов. Например, следующий код запускает 100000 отдельных корутин, каждая из которых ожидает 5 секунд, а затем выводит точку ('.') при очень низком потреблении памяти:

import kotlinx.coroutines.*

fun main() = runBlocking {
    repeat(100_000) { // launch a lot of coroutines
        launch {
            delay(5000L)
            print(".")
        }
    }
}

Если вы напишете ту же программу, используя потоки (удалите runBlocking, замените launch на thread, и замените delay на Thread.sleep), скорее всего, она потребляет слишком много памяти и вызовет ошибку недостатка памяти.