В чем разница в обработке ошибок между Flow и Coroutine?

Обработка ошибок в Flow и Coroutine: фундаментальные различия

Обработка ошибок в Flow (поток данных) и Coroutine (сопрограмма) имеет существенные различия, обусловленные их природой и предназначением. Корутины — это легковесные потоки выполнения, а Flow — это холодный асинхронный поток данных, построенный на корутинах. Различия в обработке ошибок проистекают из этой архитектурной разницы.

Обработка ошибок в Coroutine

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

1. try/catch для синхронного кода:

   suspend fun fetchData(): String {
       delay(1000)
       throw RuntimeException("Ошибка сети")
   }
   
   fun main() = runBlocking {
       try {
           val result = fetchData()
       } catch (e: Exception) {
           println("Поймано исключение: ${e.message}")
       }
   }
   

2. Обработка асинхронных ошибок через async/await:

   fun main() = runBlocking {
       val deferred = async {
           fetchData()
       }
       
       try {
           val result = deferred.await()
       } catch (e: Exception) {
           println("Асинхронная ошибка: ${e.message}")
       }
   }
   

3. CoroutineExceptionHandler для корневых корутин:

   val handler = CoroutineExceptionHandler { _, exception ->
       println("Непойманное исключение: ${exception.message}")
   }
   
   fun main() = runBlocking {
       val job = launch(handler) {
           throw RuntimeException("Критическая ошибка")
       }
       job.join()
   }
   

Ключевая особенность: при возникновении исключения в корутине оно распространяется вверх по иерархии, вызывая отмену родительских корутин (если не используется SupervisorJob).

Обработка ошибок в Flow

Flow — это поток данных, где ошибки могут возникать в процессе эмиссии элементов. Основные механизмы:

1. catch оператор для локальной обработки:

   fun getNumbers(): Flow<Int> = flow {
       for (i in 1..3) {
           if (i == 2) throw RuntimeException("Ошибка на элементе $i")
           emit(i)
       }
   }
   
   fun main() = runBlocking {
       getNumbers()
           .catch { e -> emit(-1) } // Ловим ошибку и эмитим fallback-значение
           .collect { value -> println(value) }
   }
   

2. Комбинация catch с onCompletion:

   getNumbers()
       .onCompletion { cause -> 
           if (cause != null) println("Поток завершился с ошибкой: $cause")
       }
       .catch { e -> println("Обработка ошибки: ${e.message}") }
       .collect { println(it) }
   

3. retry и retryWhen для повторных попыток:

   getNumbers()
       .retry(3) { cause ->
           if (cause is IOException) {
               delay(1000)
               true // Повторяем попытку
           } else {
               false // Не повторяем для других ошибок
           }
       }
       .collect { println(it) }
   

4. Обработка в коллекторе через try/catch:

   try {
       getNumbers().collect { value ->
           println(value)
       }
   } catch (e: Exception) {
       println("Поймано в коллекторе: ${e.message}")
   }
   

Ключевые различия

Важные особенности Flow

1. Холодная природа: Каждый вызов collect запускает поток заново, включая обработку ошибок.
2. Прозрачность завершения: Оператор catch не ловит ошибки ниже по течению (после себя).
3. Сохранение контекста: Ошибки в Flow сохраняют контекст вызова, что упрощает отладку.

Практический пример комбинации

fun main() = runBlocking {
    val flow = flow {
        emit(1)
        delay(100)
        throw IOException("Сетевая ошибка")
    }
    
    flow
        .retry(2) { cause ->
            cause is IOException && attempt < 3
        }
        .catch { e -> 
            if (e is IOException) emit(-1)
            else throw e
        }
        .collect { value ->
            println("Получено: $value")
        }
}

Вывод: Обработка ошибок в Coroutine фокусируется на управлении выполнением кода и отмене операций, тогда как в Flow акцент сделан на непрерывности потока данных и возможности восстановления после сбоев. Flow предоставляет более декларативный и композируемый подход к обработке ошибок через цепочку операторов, в то время как корутины требуют более императивного стиля с try/catch блоками.