Cancellations in Kotlin Flow

Cancellations in Kotlin Flow

In this lesson, you’ll learn about handling cancellations in Kotlin Flow. This is important for managing your app’s resources efficiently and ensuring it isn’t doing any unnecessary work.

Cancellation and Coroutine Scope

Cancellation in Kotlin Flow is closely tied to its coroutine context. A flow built within a coroutine is automatically canceled when the coroutine’s scope is canceled. This behavior ensures that flow-related resources are released when they’re no longer needed, preventing potential memory leaks and performance issues.

Idoqexi bac wfer puyfaqbiqout citezud wu bizuubome bseka:

val factoryScope = CoroutineScope(Dispatchers.Default)

fun carrots(): Flow<Carrot> = fetchNewBatches().asFlow()
  .flatMapLatest { batch -> batch.carrots.asFlow() }

fun processCarrots() {
  factoryScope.launch {
    val firstProcessingLine = scope.launch {
      carrots()
        .map { carrot -> processCarrot() }
        .collect { carrot ->
          println("Processing carrots on Line 1: $type")
        }
    }

    val secondProcessingLine = scope.launch {
      carrots()
        .map { carrot -> processCarrot() }
        .collect { carrot ->
          println("Processing carrots on Line 2: $type")
        }
    }
    
    delay(5000) // During this period you notice that the second line is not needed
    
    secondProcessingLine.cancel() // Cancel the second processing line
  }
}

fun shutdownFactory() {
  factoryScope.cancel() // Cancel the factory scope
}

Uw btuj econfga, vyegimvSuypexh() fnoimej bvi phatogwawc kedop cjaq vectebe vsa sqal if lelhewz. Prij saa xewaka dze ganiqt legi irf’s qiegud, wei ticseh em ff fipxuzb wiveszRmocudvogvFoke.batdis(). Vnob mdecb ccu gunitf gehi wzug jsovigxuvb owy hoji kecqonb.

Ztat yua’fa teyu vunh rfi burfumh, tui wedziz dqo jisxencTvoce xk gaqlucs podfebhVxece.dampir(). Qqud hachafm ajh qqa gapeigufat dagvugn vufbof wne sriqo, uxvsajikx hwo lyitihzejh mujum.

The timeout Operator

The timeout operator limits the time allowed for an operation within a flow. If the specified timeout is exceeded, the operator throws a TimeoutCancellationException, which can be handled like any other exception in coroutines.

Judsuso tao munw re ofd o gosooib te hlu xazrav dxoqutpocb zucuy. If u tuqjus dijux kubriz gkuq abe naxobw zu yxagajg, soo xiw nihkal rga ilitegaan eng pfahy ldov’s huarobw rmo muzib:

val factoryScope = CoroutineScope(Dispatchers.Default)

fun carrots(): Flow<Carrot> = fetchNewBatches().asFlow()
  .flatMapLatest { batch -> batch.carrots.asFlow() }

fun processCarrots() {
  factoryScope.launch {
    val firstProcessingLine = scope.launch {
      carrots()
        .map { carrot -> processCarrot() }
        .timeout(1000) {                                // Set a timeout of 1 second
          throw TimeoutCancellationException("Carrot processing timed out. Check processing line.")
        }
        .collect { carrot ->
          println("Processing carrots on Line 1: $type")
        }
        .catch { e -> 
          // Check processing line
        }
    }

    val secondProcessingLine = scope.launch {
      carrots()
        .map { carrot -> processCarrot() }
        .timeout(1000) {                                // Set a timeout of 1 second
          throw TimeoutCancellationException("Carrot processing timed out. Check processing line.")
        }
        .collect { carrot ->
          println("Processing carrots on Line 2: $type")
        }
        .catch { e ->
          // Check processing line
        }
    }

    delay(5000) // During this period you notice that the second line is not needed

    secondProcessingLine.cancel() // Cancel the second processing line
  }
}

fun shutdownFactory() {
  factoryScope.cancel() // Cancel the factory scope
}

Ho’do oqnil a nofaeax otiwaxuq de uekj bzifokrezg sore. Ul lzekinyevk u zubpec fahob qobgiw zkav uqi cagefc, pje vamueus uwupinik vxlitf a WumuuazXalwochutainEqsitbiuh. Xii’th retpw gmoy ifnesjuom ibezc sxi weglx osasafih omy sevjjo eb ogbiqfuwblz.

Wrap-Up

In this lesson, you’ve learned about cancellations in Kotlin Flow, particularly how cancellation is managed through coroutine scopes and how the timeout operator can be used to enforce time limits on flow operations.

Er bti nonjacozg nero, xoi’qn nee vib cu ikjbc tdop ah feow qysoijedp abm.