I’m curious if this example is my fault, or if it’s a coroutines issue - but I want to get an easy to debug stacktrace https://github.com/Kotlin/kotlinx.coroutines/issues/1661

Why Actors is not multiplataform ?

How can I cancel something using another scope? I have a class that has it's own lifecycle scope. Now when someone calls a suspend funtion on that class I want that function to get cancelled when the scope of the class is cancelled.

I’m seeing the following problem: If I cancel a coroutine with a specific exception as the cause on the JVM, I can access that cause with exception.cause. But if I run the same code on K/N, the cause is null. Any ideas how to solve this? Ironically, the exception.message still states, that it was caused by the correct exception, I just don’t have access to it.

(Update from earlier): I want to cache/share a Flow (like rx's replay)? E.g. I have

flow { 
    emit(expensiveNetworkOperation1())
    emit(expensiveNetworkOperation2())
    emit(expensiveNetworkOperation3())
}

and I want to collect that flow repeatedly, without repeating the expensive operations. Here's my solution. Feedback? Gotchas I'm missing?

/**
 * Collects the upstream source a single time, and sends cached values to any future collectors
 */
fun <T> Flow<T>.replay(): Flow<T> {

    val upstream = this

    return object : AbstractFlow<T>() {

        val isFinished = AtomicBoolean()
        val isCollecting = AtomicBoolean()

        val values = mutableListOf<T>()

        override suspend fun collectSafely(collector: FlowCollector<T>) {
            coroutineScope {

                // Collect the upstream flow (but only once) and remember the values it emits
                if (!isCollecting.getAndSet(true)) {
                    launch {
                        upstream.collect { values += it }
                        isFinished.set(true)
                    }
                }

                // Create a downstream flow that just emits cached values
                val downstreamFlow = flow {
                    var i = 0
                    while (!isFinished.get()) {
                        while (i < values.size) {
                            emit(values[i])
                            i++
                        }
                        delay(1)
                    }
                }

                collector.emitAll(downstreamFlow)
            }
        }
    }
}

This message was deleted.

[

QUESTION

] Hello mates, I always hear people saying that RxJava is really powerful and coroutines it's a lighter solution. And they say that the situation to use RxJava is when you should use all those Rx operations (e.g.

transform, map, etc

). Thinking about this I was wondering if it's possible to do the same only with Coroutines and pure Kotlin, and if not, what is it so powerful in Rx?

Hello, World! I've been using coroutines for about a year now, but am still unclear (or even confused) about a few details. The same thing happened to me with Rx, until I read a very good book about it and it all became clear. Can anyone recommend a book about Coroutines?

If i was intended to cancel the scope then how to handle/suppress

JobCancellationException

at once?

is there a way to schedule a block of code to run on a block completion when run with

withContext

? (I’m trying to time some functions)

Is there currently a way to implement some kind of

share

operator on

Flow

(at least in the meantime until it shows up in the library)? As in https://github.com/Kotlin/kotlinx.coroutines/issues/1261 ...

broadcastIn

and

asFlow

is probably hot... so a fast upstream might lead to lost emissions unless a buffer is properly configured...

Is there a release for 1.3.60 coming soon?

https://kotlinlang.org/docs/reference/coroutines/coroutine-context-and-dispatchers.html#dispatchers-and-threads appears to be the starting point i am looking for, and i find "newSingleThreadContext". I think to myself that having threads with CPU affinity is good for breaking a memory mapped file into N lines/CPU chunks. upon clicking on that link i read bold letters: "*NOTE: This API will be replaced in the future.*" In c++ there is openMP, and a pragma lets you simply annotate a loop to parralelize it. Is there something so simple I am missing from the coroutines docs?

what is the entity responsible for resuming a coroutine? Is it a

Dispatcher

?

Is there any way to combine flow items in to list without termination?

Hi all, I'm trying to write a coroutine based DataLoader to be used on within a GraphQL implementation. I've made a simple Slideshow of what I want to achieve: https://docs.google.com/presentation/d/1lh5MzqM36xDvIkDsK8NGIlmfxq5uuPXbgAT4Kf9CjLw/ Anyone that could guide me to which coroutine tools I should use for something like this?

What is the impact of running the coroutines debug agent in production? I find it really useful to do

kill -5

to get insight into the running coroutines, but always see the "do not use in production" warnings.

Hello there. This is an Android-related question. I need to load images from some remote source. These images are

BLOB

objects. I implemented a service that fetches these images by leveraging the power of Kotlin

Coroutines

. This service is quite simple, it just exposes a

suspend fun

. I used it as one-shot operation inside a

ViewModel

, so the scoping here was easy. Now I need to use this image loader inside a

RecycerView

. So the scoping there gets tricky: how do I manage a

CoroutineScope

inside a

RecyclerView

? As far as I understand, I cannot use

Glide

,

Picasso

or

Coil

, since it is bound to uri/url image sources. So I need to implement it myself. Where do I start? Should I somehow use a

LifecycleOwner

in order to get that scoping feature? Any help will be very appreciated. 🏅

Hi all A little confused about thread in couroutine. Basically, we all use

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

for call api from network. But I am confused that where need we specified the dispatcher. For example: I have a UserViewModel class and FetchUserUseCase class.

Pattern 1

1. FetchUserUseCase.kt

suspend  fun fetch(): UserResponse {
   return runCatching {
            withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
                clientApi.get()
            }
        }
}

2. UserViewModel.kt

fun fetch() {
   viewModelScope.launch {
     fetchUserUseCase.fetch()
   }
}

Pattern 2

1. FetchUserUseCase.kt

suspend  fun fetch(): UserResponse {
   return coroutineScope {
          clientApi.get()
   }
}

2. UserViewModel.kt

fun fetch() {
   viewModelScope.launch {
      runCatching {
         withContext(<http://Dispatchers.IO|Dispatchers.IO>) {
           fetchUserUseCase.fetch()
         }
      }
   }
}

Above 2 way of writing is the same ? Where need we specified dispatcher ? ViewModel or UseCase

Question: why hasn't 1.3.2 for Kotlin (Native) 1.3.60 been published as just 1.3.3 instead of 1.3.2-1.3.60? The versioning scheme looks more complicated than it should IMHO.

Is there some issue with

org.jetbrains.kotlinx:kotlinx-coroutines-io-jvm:0.1.16

?

how to create a coroutine scope inheriting parent context but does not cancel parent scope if it was cancelled

I have a map that is going to be used by multiple coroutines; its entries will be read and modified. How to make sure this map is thread-safe? I came across mutex and atomics but I'm not sure what's the difference between them. I know

Mutex

uses atomics internally too and that made me more confused. I also don't fully understand how atomics work in the first place, like in what case would they lock the object? Would putting my map in an atomic guarantees the operations performed will be synchronized? etc

Hey I have a question about

callbackFlow

again. How would you review following code:

fun TextView.onTextChange() = callbackFlow {
    val listener = addTextChangedListener { text ->
        if (text != null) {
            offer(text.toString())
        }
    }
    awaitClose { removeTextChangedListener(listener) }
}

hi, how you deal with lifecycle-aware

CoroutineScope

inside a compound view? is safe that pass

LifecycleScope

from

Fragment

to view? or i have to handle that with lifecycle events?

I'm looking for a way to subscribe to a conflated

BroadcastChannel

but ignore any items that may already be in that channel at the time of subscription. Is this possible? (example in thread)

What is the right way to get a count of pending messages in actor’s “mailbox” from outside? Should I expose its

ReceiveChannel

and do something like

channel.asFlow().count()

?

does wrapping blocking calls

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

stop my threads from getting 'blocked'?

If I launch a bunch of them will all my threads eventually get hung? because at the end of the day they are blocking calls inside the withContext?