I am looking for some help in debugging an issue. I am quite new to coroutines so please pardon my unfamiliarity. There is a long-running job (

launch

) which polls data from a stream, and the reader is closed on

job.invokeOnCompletion

. We use

suspendCancellableCoroutine

to register a callback with the reader. 1 data point is polled at a time. We started seeing a potential memory leak with

CancellableContinuationImpl/ChildContinuation

created as part of

suspendCancellableCoroutine

. We expected only 1 active

CancellableContinuationImpl/ChildContinuation

per job and that is the case but job holds reference to old

ChildContinuation

from earlier which prevents it from getting GC'd (in the

nodeList

) My understanding is that it is detached from the job on successful invocation of

resume

, which is what is expected from our service and even in the heap dump the

state

of `ChildContinuation`denotes it. I am wondering if there is any other scenario where

CancellableContinuationImpl/ChildContinuation

is not removed from the

nodeList

? Or if there is a delay in removing it.

Are these two basically identical? What’s the difference?

fun suspendFoo(scope: CoroutineScope): Deferred<Int> =
        scope.async { 4 }
    
    suspend fun foo(): Int {
        delay(0)
        return 4
    }

Is it expected that the latest stable release of coroutines is still on Kotlin 1.6.21 instead of on 1.7.x?

By “thread safe” here they just mean that it won’t break when multiple threads use it at the same time.

1.6.4-native-mt was never released? https://search.maven.org/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-bom

Is there a better way to keep parallelism in the

initializeStuffAndGetFoo()

function between my coroutines without this dangerous

first() as String

? https://pl.kotl.in/7fVqO3EXP

import kotlinx.coroutines.*

fun main() = runBlocking {
    println(initializeStuffAndGetFoo())
}

suspend fun initializeStuffAndGetFoo() = withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
    listOf(
        async { getFooValue() },
        async { initA() },
        async { initB() },
    ).awaitAll().first() as String
}

suspend fun getFooValue(): String {
    delay(2_000)
    return "Foo"
}

suspend fun initA() = delay(1_000)
suspend fun initB() = delay(3_000)

Is it possible to start a Coroutine in a flow operator, so that when the flow completes, the Coroutine is cancelled as well? I somehow need access to the scope of the flow, right?

so I have this piece of code:

if (marketingConsentTypes != null && marketingConsentTypes.all { it in validEnumValues }) {
    viewModelScope.launch(coroutineDispatchers.main) {
        marketingConsentTypes.forEach { consentType ->
            giveConsent.execute(
                GiveConsent.Input(
                    consentType = GiveConsent.ConsentType.valueOf(consentType),
                    hasGivenConsent = true
                )
            ).await()
        }

        isLoading.postValue(false)
    }
} else {
    error.postValue(Event(Throwable()))
}

the issue is not that I am running this usecase in a loop, that’s what I want the issue is that I would like to get back the Throwable that this usecase already does return for me, with Rx usually I’d get it back in the error block of the subscribe, here where can I get it to let my mutable property know that the error happened?

Is there a way to ensure consistency between flows? I want to ensure that several related flows’ values are consistent in terms of events they processed

If say the value shared flowA and FlowB directly or indirectly depend on emitted value of flowC, I want to ensure I observe the value of those flows when both processed the latest value of flowC

But I don't want to observe the values when one flow processed the latest value but the other hasn't

If I have a

Flow<Int>

, say 1, 20, 30, 35, how could I produce a flow which "samples" this flow and counts the difference between last elements emitted in chunked time windows? for example sampleTime=20ms if

1,20, 30

got emitted in 20ms since start and then only one item

35

got emitted in next 20 ms, I would get

29,5

(

30-1,35-30

) out. Should I combine sample with map with timestamps? Would be grateful for direction. Or should I write a fully custom "transform" function instead of trying to combine existing ones?

what is an idiomatic way to issue a list of io-blocking calls and do something with each result as soon as it completes?

When a component is destroyed, its CoroutineScope is cancelled. Id like to do one last thing at that point, do I do

GlobalScope.launch {}

or `scope.launch(context = NonCancellable) {}`; or are they basically the same thing? My operation is just a few millis long.

Hello, I was wondering if its possible to ensure continuation is ran on same thread from call site, for e.g

suspend fun test() {
    val response = bar()
    println("I want this to be on same thread as it was before doing bar call")
}

suspend fun bar() {
    val response = someOtherCallThatSwitchesThread()
    return response
}

I figured calling

suspendCoroutine

inside bar then launching new coroutine that resumes the continuation with the response would work and while it does change the thread, it doesnt go back to original.

Whats the recommended approach for using

scope.launch {}

from MainScope? Generally, the task itself will run with the "correct" dispatcher, for example: loading something from a database is always executed using

withContext(<http://Dispatchers.IO|Dispatchers.IO>)

. But to me it seems that I might as well specify something like

Dispatchers.Default

in the launch block, so that all tasks are at least off-loaded from the main thread by default? As a real life scenario, I was just working on an issue where UI froze after the user had selected a file to import from; I had failed to realize that contentResolver.openInputStream(uri) was blocking rather than reading from the inputStream itself. If I had been using

Dispatchers.Default

, this wouldnt have been a problem. Now, instead I have to wrap each individual call like this (there arent many, but still) in a

withContext(Dispatchers.Default/IO)

.

Hello, can anybody point me to a guide for debugging hanging coroutines setup? I looked at a thread dump, but it only shows a bunch of parked coroutines. I would like to get a graph of suspended continuations or something.

check that delay imports

How can this be rewritten in a better way wrt structured concurrency and flow etc

fun <A, B> Iterable<A>.parallelMap(context: CoroutineContext, f: suspend (A) -> B): List<B> = runBlocking {
    map { async(context) { f(it) } }.map { it.await() }
}

@OptIn(ExperimentalCoroutinesApi::class)
private val apiPool = Dispatchers.IO.limitedParallelism(10)

val results = foo.parallelMap(apiPool) { fetchStuffFromRestAPI(it.id) }

Who can help me with next: how can I test the emitted value from

MutableSharedFlow

which uses debounce? Example: I’m using this flow to track the input text in textfield, debounce and distinct it, and if it passes I make some calculations. But if in unit test I emit the value, it never enters the

collectLatest {}

lambda.

Is the

future

function in

kotlinx-coroutines-jdk8

available as per the sample code? https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-jdk8/#:~:text=to%20the%20future-,Example,-Given%20the%20following The definition shows that a

CoroutineScope

is required, and actually reproducing the sample code results in a compile error. https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-jdk8/kotlinx.coroutines.future/future.html Also, if there is a way to achieve the same behavior as in the sample code, I would appreciate it if you could let me know.

I want to cancel all the pending work thats being done in my

CoroutineScope

, but I need to do it inside a suspending block of my scope. This feels like a really bad idea, is there a better approach?

scope.launch {
    // Do some suspending work
    scope.coroutineContext.cancelChildren()
    // Ordering becomes very important - any code from here and on is never executed.
    // This isnt a problem by itself as I dont have any more code here, but it has introduced very subtle
    // bugs in the past
}

I am attempting to perform parallel API calls with kotlin. However, the second api call is cancelled when the first call's await() method is called. How do i force all methods to finish executing before returning from the method. The code snippet

suspend fun isFinished(token: String): Boolean {
    return coroutineScope {
        val a = async {
            updateProfile(token = token)
        }
        val b = async{
            updateStatus(token = token)
        }
        (a.await()) && (b.await())
    }
}

Methods updateProfile(token: String) and updateStatus(token: String) are the api methods

Are there any use cases for using Channels in Android Development, or are you exclusively using Flows in your apps?

Is there any known weirdness with the latest stable versions of kotlin/coroutines and Mockito? I'm having an issue where my tests are provided mocks, the debugger confirms it's a mock, but the code actually tries to execute in those mocks

After upgrading to 1.6.21 from 1.5.21 we are getting fatal reports of

kotlinx.coroutines.JobCancellationException

,

kotlinx.coroutines.TimeoutCancellationException

in firebase crashlytics. We are not able to reproduce this ourself. Any help appreciated?

I faced with a problem when using runBlocking and flow::stateIn https://stackoverflow.com/questions/73442324/problem-with-kotlin-coroutine-runblocking-and-statein

Hi everyone! Is there a way to reuse the continuation in

suspendCoroutine

block?

suspendCoroutine { continuation -> }

I need to call continuation more than once but its throwing error

java.lang.IllegalStateException: Already resumed
        at kotlin.coroutines.SafeContinuation.resumeWith(SafeContinuationJvm.kt:44)

Any way to bypass this?

How can I print out the coroutine context in which a flow operator is running?