Как создать корутину с отложенным запуском?

Создание корутины с отложенным запуском

В Kotlin корутины с отложенным запуском (lazy start) создаются с помощью параметра start = CoroutineStart.LAZY. Это позволяет инициализировать корутину, но не запускать её немедленно — выполнение начнётся только при явном вызове метода start() или await() (для Deferred).

Основные способы

1. Использование async с LAZY

Наиболее распространённый сценарий — ленивые вычисления с возвратом результата.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Создаём отложенную корутину с возвратом результата
    val deferredResult = async(start = CoroutineStart.LAZY) {
        println("Вычисления начаты")
        delay(1000)
        "Результат"
    }
    
    println("Корутина создана, но не запущена")
    delay(2000) // Имитация других операций
    
    // Явный запуск корутины
    deferredResult.start()
    // Или deferredResult.await() — запустит и дождётся результата
    
    val result = deferredResult.await()
    println("Получен результат: $result")
}

2. Использование launch с LAZY

Для фоновых задач без возвращаемого значения.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val lazyJob = launch(start = CoroutineStart.LAZY) {
        println("Фоновая задача выполняется")
        delay(500)
        println("Задача завершена")
    }
    
    println("Основной поток продолжает работу")
    delay(1000)
    
    // Запускаем отложенную корутину
    lazyJob.start()
    
    // Ждём завершения
    lazyJob.join()
    println("Все операции завершены")
}

Ключевые особенности отложенных корутин

Поведение при запуске

• start() — запускает корутину асинхронно, не дожидаясь завершения
• await() (для async) — запускает корутину и блокирует текущий поток до получения результата
• join() (для launch) — запускает и ждёт завершения без возврата значения

Потокобезопасность

Методы start(), await() и join() потокобезопасны и могут вызываться из разных потоков.

import kotlinx.coroutines.*
import java.util.concurrent.atomic.AtomicInteger

fun main() = runBlocking {
    val counter = AtomicInteger(0)
    val lazyJob = launch(start = CoroutineStart.LAZY) {
        delay(100)
        counter.incrementAndGet()
    }
    
    // Параллельные попытки запуска из разных потоков
    List(10) {
        Thread {
            runBlocking { lazyJob.start() }
        }.apply { start() }
    }
    
    delay(200)
    println("Счётчик: ${counter.get()}") // Всегда 1 — корутина выполнится только один раз
}

Практические сценарии использования

Оптимизация ресурсов

class DataLoader {
    private val cachedData = mutableMapOf<String, Deferred<String>>()
    
    suspend fun loadData(key: String): String {
        val deferred = cachedData.getOrPut(key) {
            CoroutineScope(Dispatchers.IO).async(start = CoroutineStart.LAZY) {
                println("Загрузка данных для $key")
                // Дорогая операция
                delay(2000)
                "Данные для $key"
            }
        }
        return deferred.await()
    }
}

Контролируемый параллелизм

suspend fun processBatch(items: List<Int>, maxConcurrent: Int) {
    val deferredResults = items.map { item ->
        async(start = CoroutineStart.LAZY) {
            processItem(item)
        }
    }
    
    // Запускаем только maxConcurrent корутин одновременно
    deferredResults.chunked(maxConcurrent).forEach { chunk ->
        chunk.forEach { it.start() }
        chunk.forEach { it.await() }
    }
}

Важные предупреждения

1. Риск взаимоблокировок — если отложенная корутина зависит от другой отложенной корутины:

// ПРИМЕР ПРОБЛЕМНОГО КОДА
val deferredA = async(start = CoroutineStart.LAZY) {
    deferredB.await() + 10
}
val deferredB = async(start = CoroutineStart.LAZY) {
    deferredA.await() - 5
}
// Вызов deferredA.await() приведёт к deadlock!

1. Отмена корутин — отложенные корутины можно отменить до запуска:

val job = launch(start = CoroutineStart.LAZY) {
    println("Эта строка не выполнится")
}
job.cancel() // Отменяем до запуска

Сравнение с другими стратегиями запуска

Заключение

Отложенные корутины — мощный инструмент для оптимизации работы асинхронного кода. Они позволяют:

• Откладывать дорогостоящие вычисления до реальной необходимости
• Контролировать момент запуска параллельных операций
• Создавать ленивые инициализаторы ресурсов
• Управлять параллелизмом в сложных сценариях

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