there isn’t a coroutines standard lib function for retries is there?

Is there a way to 'cache'/share a Flow? E.g. I have

flow { expensiveNetworkOperation() }

and I want to collect that flow repeatedly. What's the best way to prevent duplicating the expensiveNetworkOperation() call?

Hey, I was reading some androiddev stuff on reddit and i've stumbled upon Vasiliy's rant on coroutines: https://www.techyourchance.com/kotlin-coroutines-in-complex-scenarios/. Apart from doing weird points he mention blocking issue - i've investigated his code but I need some help with understanding the reason. For me it looks like deadlock - dispatcher tries to dispatch coroutine on already locked (BlockingQueue) thread and we're ending up with Producers or Consumers only without chance to dispatch other type of worker. Am I right?

Hi, how would one migrate Single.fromCallable { } into coroutines? Should I just leave it as regular blocking function?

How to transform data using coroutines in each repository layer? Something like we do in RxJava using map or flatmap. For example, using flatmap in remote layer for converting necessary changes and use that output in data layer

CompletableFuture.await()

, how much overhead does

await()

add in the scenario where the

CompletableFuture

is not yet done?

public suspend fun <T> CompletionStage<T>.await(): T {
    // fast path when CompletableFuture is already done (does not suspend)
    if (this is Future<*> && isDone()) {
        ...
    }

    // slow path -- suspend
    return suspendCancellableCoroutine { cont: CancellableContinuation<T> ->
        val consumer = ContinuationConsumer(cont)
        whenComplete(consumer)
        cont.invokeOnCancellation {
            // mayInterruptIfRunning is not used
            (this as? CompletableFuture<T>)?.cancel(false)
            consumer.cont = null // shall clear reference to continuation to aid GC
        }
    }
}

Is the overhead just extra class instances being created or is there more happening?

How do you guys handle coroutines in android, which want to outlive the viewmodel scope? should repository or whatever does the couroutine have its scope, and be transparent to the viewmodel or should that scope be passed into the viewmodel and viewmodel launches the coroutine into that scope?

withContext(Dispatchers.IO) { }, would you guys say this is similar to the coroutine saying "hey i'm about to perform some slow task, does anyone else speedier want to jump in before me?"

Anyone have any experience writing to Android’s AudioTrack using coroutines? If so, any tips/gotchas etc? I’m thinking particularly in terms of managing buffering (because want to calculate PCM data lazily since it could be very large) and managing playback state.

Is there a coroutine equvalent for

lazy

? I'm not looking for

async

. All I want is execution in the current coroutine, if the value was not yet computed.

Trying to invoke a coroutine from Java, for some legacy code. This doesn't start it so far, do I miss something?

CoroutineScope scope = ViewModelKt.getViewModelScope(this);
        BuildersKt.launch(scope, scope.getCoroutineContext(), CoroutineStart.DEFAULT,
                (_scope, continuation) -> signUp.invoke(params, continuation)
        );

somebody know some inbuilt function similar to apply() which can execute suspendable block of code?

Is it possible to subclass a KClass from java that contains a suspend function? When I try I get given a Continuation object, that I have no idea how to use

Hi, if I for loops async { }, is there a guarantee of order of them starting to run? I have a semaphore inside them, but it seems race-y

Can I conditionally park a coroutine, and resume it after some signal?

Is there anyway to know if a Job has been cancelled other than checking

isActive

or having a CancellationException thrown?

Ehm, I might be stupid -- how can I await on List<Deferred> ? deferreds.forEach { it.await() } seems to make it sequential

Good morning (for some at least i guess 😅 ) I'm starting to use flows and I wonder how can i specify the thread the function I pass onto

collect

is executed. I'm trying:

launch(UI) {
  flow.collect {
    // i was hoping this was executed in UI
  }

should that be running in the UI Dispatcher?

In

CoroutineScope(Dispatchers.Main + job)

the order of contexts doesn’t matter and it’s the same if I call

CoroutineScope(job + Dispatchers.Main)

, right?

Hello! I have a problem with simple flow sample:

flowOf(1,2,3).collect { value -> println(value)  }

It doesn't compile cause: Type mismatch: Required: FlowCollector<Int> found (Nothing) -> Unit What i doing wrong?

So if actors are obsolete, what should I be using in their place? Or am I missing something?

What's the best way to run a coroutine environment application in jvm? Basic structure of application that i want is as shown

fun main() {
    Foo()
}

class Foo {
    val bar = Bar()
}

class Bar() {
    // perform some long running tasks with some part dependent on foo
}

Case 1:

fun main = runBlocking { //this: CoroutineScope
    Foo(this)
}
class Foo(scope: CoroutineScope): CoroutineScope by scope {
    val bar = Bar(this)
}

class Bar(val foo: Foo): CoroutineScope by foo {
}

Case 2:

fun main = runBlocking { //this: CoroutineScope
    Foo(this)
}
class Foo(scope: CoroutineScope): CoroutineScope {
    override val coroutineContext = scope.coroutineContext
    val bar = Bar(this)
}

class Bar(val foo: Foo): CoroutineScope {
    override val coroutineContext = foo.coroutineContext
}

Case 3:

fun main() {
    //just dont start coroutine here
    Foo()
}

class Foo: CoroutineScope {
    override val coroutineContext = Dispatchers.Default
    val bar = Bar(this)
}

class Bar(foo: Foo): CoroutineScope {
    override val coroutineContext = Dispatchers.Default
}

Or if there is a better way to create a coroutine driven application?

Also what is difference between Dispatchers.IO and Dispatchers.Default

fun main() = runBlocking<Unit> {
	launch(Dispatchers.Default) {
		println("Default               : I'm working in thread ${Thread.currentThread().name}")
	}
	launch(<http://Dispatchers.IO|Dispatchers.IO>) {
		println("IO                    : I'm working in thread ${Thread.currentThread().name}")
	}
}

Output:

Default               : I'm working in thread DefaultDispatcher-worker-1
IO                    : I'm working in thread DefaultDispatcher-worker-3

Is there a way to read/write a file without blocking a thread at all that I could put in a simple extension function? Right now, the easiest way I know is blocking a thread from

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

and using

readText()

or

readBytes()

, but this still blocks a thread while we are waiting for storage and not the CPU.

Does anyone else have a use case for multi-shot continuations?

Idiomatic way to lazily instantiate AND initialise a class that should only ever be instantiated and initialised max once. At the moment I have:

private lateinit var deferredFactory: Deferred<MyFactory>

suspend fun getMyFactory(): MyFactory = withContext(Dispatchers.Main) {
    if (::deferredFactory.isInitialized) {
        return@withContext deferredFactory.await()
    }
    val deferred = CompletableDeferred<MyFactory>().apply {
        deferredFactory = this
    }
    createFactory().also {
        deferred.complete(it)
    }
}

private suspend fun createFactory() = withContext(Dispatchers.Default) {
    // slow stuff
}

=== UPDATE ===
After all the comments, this is what we came up with:

private val deferredFactory = GlobalScope.async(start = CoroutineStart.LAZY) {
    createFactory()
}

suspend fun getFactoryOrNull() =
    try {
        deferredFactory.await()
    } catch (e: Exception) {
        //loge("unable to create factory", e)
        null
    }

What is the best dispatcher for file io? My understanding is that the io dispatcher strongly scales (creates unbounded? amount of threads) due to the assumption that io will mostly sleep. The default dispatcher is ment for CPU bound work and therefore limits it's thread utilization to the number of CPUs (-1) to not schedule more work than the CPUs can handle. Now file io puts a CPU in io wait state. Should this be considered CPU bound and hence the default dispatcher should be used?

Hi guys, what is the easy way to have something like ConcurrencyHashMap in Kotlin Multiplatform with Coroutines multiplatform? I'm building a library that the functions changes the values of a Map, removing, searching and adding values, and anyone that calls this functions can call in different threads(or workers in native if I'm correctly)

val one = GlobalScope.async(start = CoroutineStart.LAZY) { A() }
    val two = GlobalScope.async(start = CoroutineStart.LAZY) { B() }

    one.start()
    Thread.sleep(1000)
    two.start()

is there a better way to wait for

one

to start first before starting

two

without using Thread.sleep in between?