is there any particular reason why

flatMapLatest

and

transformLatest

are still marked with

@ExperimentalCoroutinesApi

?

Hi all. Wanted to see if I’m using

join

in a proper manner and/or if there is a better way to do what I’m doing. I’m launching a coroutine that does some work (makes a few HTTP requests). Then later, in response to some event, I need to launch another coroutine to do some different work. When the 2nd coroutine is launched, I want to make sure the first coroutine is finished before the 2nd one does its work (it’s also ok if the first one was never launched at all). To accomplish this, I’m keeping a reference to the

Job

from the first coroutine, and calling its

join()

method from the second coroutine. A code sample is included in the 🧵 Two questions: 1. Is it OK to do it this way, or are there any problems with it? 2. Is there some better/more efficient way to do it?

Hello, so I am wondering about this piece of code

private fun startCoroutines() {
    GlobalScope.launch(Dispatchers.Main) {
        withTimeout(1000L) {
            println("This is executed before the first delay")
            stallForTime()
            println("This is executed after the first delay")
        }

        printAfterSomething("the timeout")
    }

    println("This is executed immediately")
}

suspend fun stallForTime() {
    withContext(Dispatchers.Default) {
        delay(2000L)
    }
}

after the child job inside

withTimeout

does not finish in time (because stallForTime made it take too long (2 seconds)) why does the

printAfterSomething

not get called

In a suspend function is it possible to launch a coroutine with the current scope and return immediately? The

coroutineScope

function waits for the block's completion before returning, but I want to just

launch

something with the current scope, fire and forget

Hello! What is the best way to handle cancellation excaptions? If silently rethrow them, can miss real exception. If catch - normal cancellation will be treated as exception.

so I would like to inject this usecase that I have which returns the Result class, and the method to do that is suspendable so i am using

runTest{ }

to call it, but this is causing me to be unable to answer with the type that I want now, since it’s now expecting

TestResult

, I want to return

Result.success(obj)

@ExperimentalCoroutinesApi
@Inject
fun firebaseSignInWithEmail(mock: FirebaseSignInWithEmail) {
    every {
        runTest {
            mock.invoke("anyEmail", "anyPassword")
        }
    } returns TestResult
}

Hello, I have a hot flow (MutableSharedFlow) and was wondering why I'm required to launch a new coroutine from a new scope when calling collect for the logic to continue? e.g

suspend fun func1() = CoroutineScope(Dispatchers.Default).launch {
    func2()
    println("Not called")
}
suspend fun func2() = coroutineScope {
    launch {
        someFlow.collect { logic.invoke(it) }
    }
}

Hey guys, I'm writing a low latency TCP proxy using

java.nio.AsynchronousSocketServerChannel

and I'm using coroutine channels to push my data to a

writerChannel

which is responsible for forwarding the data between a client and server. I'm noticing some start delays between when I push data to my channel and when its consumer actually starts. my code looks like something of the following

//inside the ReadHandler future, push the data read from the socket each time the future completes, also record the start time
val startTime = System.nanoTime()
writerChannel.trySendBlocking(Pair(data, startTime))

//somewhere else in the codebase, consume the data from the channel
scope.launch(Dispatchers.Unconfined) {
    writerChannel.consumeEach { (data, startTime) ->
        val startElapsed = (System.nanoTime() - startTime) / 1_000_000
        println("Took: ${startElapsed}ms to start!")

        //do some other stuff with the data
    }
}

In one of my tests, I open up 200 simultaneous connections, and every now and then it looks like a coroutine has a cold start of about (2-4)ms with some outliers of upwards of 8ms. Is there any way how I can reduce the amount of time it takes a coroutine to start like that?

Hi! I’m working on multiplatform project where I need to update all my libraries. On CI I received

There is no event loop. Use runBlocking { ... } to start one

so I changed coroutine version to

1.6.3-native-mt

. Now the issue is that many other dependencies does not use multithreaded coroutines and I receive errors - is there any way I can force them in my Android project to use this specific version?

Is there a functioning Kafka lib that works well with coroutines? Nothing fancy, just need to send some messages to my notifications service

I've got a rather callback-heavy API, which I've modeled roughly as

fun onReaderConnected(): Flow<Reader> { ... }
class Reader {
  fun onCard(): Flow<Card>
}

And I'm consuming it via

onReaderConnected() { reader ->
  reader.onCard().collect {
    ... process card ...
  }
}

Now I've run into the issue where the reader disconnects, the inner

collect

won't stop, so the new reader connection won't get activated. How do I best model that?

literally just that last field

Because the code inside

collect

is actually run as part of the call to

emit

. Use the

catch

operator instead if you don’t want that behaviour (I think…)

What are use cases for the

.cancellable()

flow operator?

I've got a

Flow

which I'm running

collectLatest()

on, but it's only firing the first time I send something into it, not the second time... what can be the reasons here?

I am learning Kotlin by reading the Programming Kotlin book. In the section about coroutine cancellations (page 319-320), it suggest to wrap long running blocking code with

async { doStuff() }.await()

to make the coroutine cancellable (see

code/async/cancelandsuspension.kts

in https://media.pragprog.com/titles/vskotlin/code/vskotlin-code.zip). Is that really a good advice? It seems like the long running blocking code is not cancelled, it is simply detached from the parent coroutine and will continue to run to completion in backround, and will block the completion of the surrounding

runBlocking

.

fun getResponse(ms: Int): String {
    val s = URL("<http://httpstat.us/200?sleep=$ms>").readText()
    println("${LocalTime.now()} Got: $s")
    return s
}

suspend fun fetchResponse() = coroutineScope {
    try {
        println(async { getResponse(4000) }.await())
    } catch (ex: CancellationException) {
        println("${LocalTime.now()} fetchResponse: ${ex.message}")
    }
}

fun main() {
    println("${LocalTime.now()} before runBlocking")
    runBlocking {
        val job = launch(Dispatchers.Default) {
            launch { fetchResponse() }
        }

        println("${LocalTime.now()} Let it run...")
        delay(2000)
        println("${LocalTime.now()} OK, that's enough, cancel")
        job.cancel()
        println("${LocalTime.now()} end of runBlocking")
    }
    println("${LocalTime.now()} after runBlocking")
}

Can anybody answer this? : https://stackoverflow.com/questions/73846708/what-does-coroutinecontext-do

Is it a good practice for library (or any generic API) to return

StateFlow

or

SharedFlow

if the particular flow behaves state-like or share-like? Or is it better to stick to

Flow

to be more generic? I was advised to do the latter, but oftentimes I find it useful to do something like

onSubscription

which is unavailable for

Flow

and having to do

stateIn

/

shareIn

when I know that underlying code already has `StateFlow`/`SharedFlow` somehow feels wasteful.

Team #coroutines, is jobCencellationException in flow coroutines is common or how can we avoid this exception

Why does the following

val shared = MutableSharedFlow<Int>()
merge(
  shared.onSubscription { shared.emit(3) },
  flowOf(100,200,300),
).collect {
  println("$it")
}

never prints

3

, only

100 200 300

? And is there a way to setup this so that I have some point where it is safe to post to

shared

to guarantee delivery to

collect

?

I just got into a heated discussion with someone who claimed kotlin coroutines are nothing like project loom virtual threads because they don't copy the call stack. I suspect he is wrong, because coroutines seem to behave just like loom virtual threads to me, but I don't know enough. Can someone enlighten me?

Hello, in a project we needed to replicate a functioning block of coroutine code we had in similar functions (the one inside

also { }

), to send an event before calling a service. We came up with this, but I think it’s ugly and was wondering if it could be simplified:

override suspend fun validateCart(request: ValidateCartRequest): ValidateCartResponse {
        supervisorScope {
            launch(Dispatchers.Unconfined) {
                domainEventsPublisher.publishCartValidationSubmitted(request.cartId)
            }
        }
        return super.validateCart(request).also { response ->
            supervisorScope {
                launch(Dispatchers.Unconfined) {
                    if (response.isValid) domainEventsPublisher.publishCartValidationSucceeded(response)
                }
            }
        }
    }

can i wrap everything in a single supervisorScope? Would it be equivalent to this code?

Hi folks, i browsed kotlinx.coroutines lib and i have a question about package structure: all flow operators even though they are in separate file their package is still

package kotlinx.coroutines.flow

. I guess this is for easier discover-ability?. I am wondering if i can use also this pattern when i seem fit in my application code or it is not recommended at all.? Thanks in advance for any help and answers ! Also how come the intelij warning is not suppressed (@file:Suppress("PackageDirectoryMismatch"))? Does not that lead to confusion if the package is intentional or not ?

Id love to understand why this piece of code becomes unresponsive when a lot of work is already being done in the background. 🧵

Maybe do you have some info about planned support for Java 19 virtual threads and

ExtentLocal

(in the foreseeable future)? Thanks.

Is there a mechanism similar to

Semaphore

that has no available 'permits' to start? I need to launch a coroutine to keep a scope alive, but have it suspend until something else tells it to "go"

Given a job

job

that was cancelled, cancellation could have been generated either from within

job

(e.g. with

job.cancel

, or one of its descendants) or by some parent job up the hierarchy. Is there any way to disambiguate between these two cases? I saw that

JobCancellationException

has a nice

job

field, but it’s not public.

Hey! Just got a job where we use Kotlin and Spring. Currently reading “Kotlin Coroutines” by Marcin and it gives good insights. Looking for books or resources (no tutorials) to learn more about Kotlin + Spring + Flow. Thx ❤️

It says `The CoroutineDispatcher that is designed for offloading blocking IO tasks to a shared pool of threads`in the comments of

<http://Dispatchers.IO|Dispatchers.IO>

. What does

offloading

mean here?