If I have a

SupervisorJob

, how can I stop all its children without an exception? If I use

supervisorJob.cancel()

, an exception is thrown.

Hi how can result be returned from this extension function

open class RootResponse<T>  {
    var success: Boolean = false
    var msg: String? = null
    var data: T? = null
}
fun <E, T : RootResponse<E>> CoroutineScope.launchCatching(blk: suspend () -> T): Result<E> {
    this.launch {
        kotlin.runCatching { blk() }
            .onSuccess {
                if (it.success && it.data != null) {
                    Result.success(it.data)
                } else {
                    Result.failure<String>(Throwable(it.msg))
                }
            }.onFailure {
                Result.failure<String>(it)
            }
    }

}

Hi 🙂 I’m looking for some resources to learn Kotlin Coroutines. Could you recommend some good courses / tutorials / books which you know?

Looking at this stack trace, curious if anyone has seen this / if it's a known issue:

Fatal Exception: java.lang.StackOverflowError: stack size 8MB
       at kotlin.Result$Failure.<init>()
       at kotlin.ResultKt.createFailure(Result.kt:121)
       at kotlinx.coroutines.DebugStringsKt.toDebugString(DebugStrings.kt:18)
       at kotlinx.coroutines.internal.DispatchedContinuation.toString(DispatchedContinuation.kt:251)
       at kotlinx.coroutines.DebugStringsKt.toDebugString(DebugStrings.kt:16)
       at kotlinx.coroutines.CancellableContinuationImpl.toString(CancellableContinuationImpl.kt:506)
       at java.lang.String.valueOf(String.java:2827)
       at java.lang.StringBuilder.append(StringBuilder.java:132)
       at kotlinx.coroutines.ResumeAwaitOnCompletion.toString(JobSupport.kt:1414)

suspend fun BarcodeScanner.processSuspending(image: ImageProxy): Barcode? {
	return suspendCancelableCoroutine { continuation ->
		continuation.invokeOnCancelation {
			this.clear()
		}

		this.process(image)
			.addOnSuccessListener { barcodes ->
				val barcode = barcodes.someTransformation()
				continuation.resume(barcode)
			}
			.addOnFailure { throwable -> 
				continutaion.resumeWithException(throwable)
			}
	}
}

Would somebody mind looking at this if I do wrap a 3rd party callback library correctly? Its googles mlkit barcode scanner. Its my first time Also, what is the best pragmatic name of providing a suspend function if the "native" is called

process()

?

processSuspending()

? or some sort of

await

variant like

awaitProcess()

? Also2, I don't need to apply dispatcher, since it provides callbacks, meaning it most likely has its own thread inside, right?

Is there an API/pattern we should be using in place of CoroutineScope.actor, since that method (and anything to do with Channels) is marked as ObsoleteCoroutineApi?

Is it possible to cancel a

Flow

manually but also waits until all launched coroutines in this flow have finished? I have a channel which is

receivedAsFlow

which in turn keeps the flow running until the channel is closed (by user or by exception). I would like to escape from this flow but also wait until all coroutines have finished...

If i call this from another function the fireAndForgetSuspendFunction(arg) never runs. If i remove the delay it runs. How can i make it run in the background with the delay?

I have a flow

flow

and a suspending function

foo

that I want to combine: when either produces a value, I want to combine the latest from both into a new emission.

combine

does that for flows, but

foo

is a suspending function that should be invoked only once. Also,

combine

doesn't emit until both sources have emitted at least once, but I want to emit either value as soon as it arrives and only start combining when both sources have produced a value. The type of the flow emissions and the return type of the suspending function are equal. I can think of some ways to do this, but there might be a very idiomatic and logical way, or even standard way of doing this. Any idea?

Let me rephrase my question (https://kotlinlang.slack.com/archives/C1CFAFJSK/p1619021225012300) with a runnable code example: https://pl.kotl.in/guoP8yGMg The output:

Getting value
tick 100
tick 200
0
tick 300
tick 400
1
Got value
tick 500
tick 600
A2
tick 700
tick 800
A3
tick 900
tick 1000
A4

The desired output

Getting value
tick 100
tick 200
0
tick 300
tick 400
1
Got value
A1 // <-- immediately emit and combine the value and the last emission from the upstream flow
tick 500
tick 600
A2
tick 700
tick 800
A3
tick 900
tick 1000
A4

I have declared

org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2-native-mt

in deps, but my Kotlin Native code doesn't have access to runBlocking. Docs seems to say it should be there: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html. I also tried adding these to

iosTest

and it didn't work: •

org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.4.2-native-mt

•

org.jetbrains.kotlinx:kotlinx-coroutines-core-common:1.4.2-native-mt

What does the note

Note that the latest element is not emitted if it does not fit into the sampling window.

mean in the documentation of

Flow.sample

? https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/sample.html How can an element not fit in a sampling window? There will always be the next window, right? Unless the sampling is cancelled while there are un-emitted events in the latest window, but are there other situations where the latest event is not emitted?

Maybe a dumb question (EDIT: certainly dumb question 🙃) but how can I force app crash (Android) when child of

SupervisorJob

(viewModelScope) throws exception? My use case is that when debugging I want my app to crash whenever there is unhandled exception anywhere in my business logic but because

viewModelScope

is

SupervisorJob

, the coroutine is only getting cancelled. This behavior can be achieved by using

Dispatchers.Main

as context (presumably because it calls android

UncaughtExceptionHandler

) but I how can I achieve this when using

.Default

or

.IO

dispatchers?

I have this use case: There is a number of network calls that are sequential, so each needs to know about the previous one. My first thought was to use

generateSequence

however it doesn’t support suspend operations 🙃 Anyone knows of an alternative for such case?

Hello 👋 Struggling to understand this simple scenario - why does the app never finish? Both strings are printed fine, but

main

never returns 😕 All I need is for

printSomethingWithDelay

to execute on a background thread, with no new coroutine, how can I achieve that?

fun main() {

    runBlocking {
        printSomethingWithDelay("something")
    }
    print("finished")
}

suspend fun printSomethingWithDelay(something: String) = withContext(AppDispatcher.appDispatcher){
    delay(1000)
    println(something)
}


object AppDispatcher {

    val appDispatcher = Executors.newFixedThreadPool(1).asCoroutineDispatcher()
}

I have a function like:

@Synchronized fun foo()

that now is being refactored to be

@Synchronized suspend fun foo()

(ℹ️ this is

kotlin.jvm.Synchronized

). The synchronisation is still needed if I don't know the context in which this will be called, right? Is there a way to also get rid of the synchronisation? Can I change to a single threaded executor to ensure calls to this function happen sequentially? Or would I need a mutex? Or is it fine as-is? I'm asking because

@Synchronized suspend fun foo()

looks a bit non-coroutinesque to me.

Hi everyone! In Kotlin Coroutines, if I have a function that returns a

Deferred

, launched on

MainScope

, should I be able to

await

until it finishes? I mean, should it block the

Main Thread

(that’s my goal, even though it sounds weird)?

Hello 👋🏽 I’ve gotta a question here which I’m not entirely sure if it relates with Coroutines or Ktor. Apologies if this is the wrong channel. Well, I’ve recently updated Kotlin

1.4.10 -> 1.4.32

and Ktor

1.4.2 -> 1.5.3

. I was definitely expecting some of Unit tests to break due to compatibility and I’ve already fixed them. However, there are still 4 of them that I’m struggling to understand what could be wrong. When one of the unit tests starts, it adds an entity to a Global Variable with type

mutableListOf<MyModel>()

. I can confirm that the value was added successfully.

ArrayList@XXXX

. However, when one of the routes of my Ktor server attempt to read the value from that Global Variable, it is empty and the id of the object is now

ArrayList@YYYY

. It looks like when

embeddedServer(…).start()

is executed, it creates a new instance of the Global Object, hence it is empty. I’ve already tried many things, SynchronizeListOf, add the global variable into an object, but no matter what I do the reference of the GlobalObject into Ktor is always different. Would anyone be able to shed some light, please? Thanks heaps.

is

GlobalScope.launch(Dispatchers.Unconfined) {
    coroutineScope {
...
   }
}

a good way to use structured concurrency in an async handler that does not know about coroutines?

Kotlin coroutines are using thread pools in background. How does coroutine can start executing in one thread, suspend execution, and resume on a different thread?

So if Swift is first then does it mean that Kotlin Actors is a different thing? 🤔 https://twitter.com/clattner_llvm/status/1386728088633974785?s=19

Howdy, Have a beginner question around coroutines. I am using coroutines in a ktor project. And multiple coroutines can increment the same prometheus counter at the same time

io.prometheus.client.Counter

The prometheus Counter is a Java library. Is there any concurrency issues people would foresee? The prometheus implementation uses Compare and Swap operations so should be coroutine safe. But saying that, there is a thread hash code used for some accounting

ThreadLocal()

.

static final ThreadLocal<int[]> threadHashCode = new ThreadLocal();
    static final Random rng = new Random();
    static final int NCPU = Runtime.getRuntime().availableProcessors();
    transient volatile Striped64.Cell[] cells;
    transient volatile long base;
    transient volatile int busy;
    private static final AtomicLongFieldUpdater<Striped64> CAS_BASE = AtomicLongFieldUpdater.newUpdater(Striped64.class, "base");
    private static final AtomicIntegerFieldUpdater<Striped64> CAS_BUSY = AtomicIntegerFieldUpdater.newUpdater(Striped64.class, "busy");

GlobalScope

is getting guard rails! My dream come true 😌

This message was deleted.

I have a flow producer which emits continuously a specific byte to represent an idle mode. I would like to drop these bytes but log them every 2 or 3 seconds. Any ideas how to achieve this?

I'm having an issue where a flow isn't being collected and I can't for the life of me figure out why basic sealed class hierarchy:

sealed class Update {
    object Success : Update()
    data class Progress(val message: String) : Update()
    data class Failure(val throwable: Throwable) : Update()
}

Success

and

Failure

emissions are collected, but

Progress

ones are not applying only two operators:

.filterNotNull()
.transformWhile { update ->
   emit(update)
   update !is Update.Failure && update !is Update.Success
}

I've debugged and logged everywhere I could, and the

Progress

objects are definitely emitted by the flow, but they never make it to the

.collect

. Am I missing something really obvious here?

I have a question related to coroutines and blocking IO integration. For integrating with a blocking library, I need a conversion similar to this:

// This is my asynchronous/suspending input stream
interface AsyncInputStream {
    // This method has semantics similar to InputStream.read() but suspends instead of blocking
    suspend fun read(): Int
}

fun AsyncInputStream.asInputStream() = object : java.io.InputStream() {
    override fun read(): Int {
        return runBlocking { this@asInputStream.read() } // Is runBlocking() correct here?
    }
}

If I understand correctly, using

runBlocking

is incorrect because it "should not be used from a coroutine", and

AsyncInputStream.asInputStream()

would possibly be called from coroutines. Thanks.

this might be a noob question but today I realized that StateFlow doesn’t work very well (or better saying intentionally doesn’t work) with Lists. So if we have the below (very rough example)

data class ViewItem(
  val id: String,
  val title: String,
  var description: String = "" // yes a var
)

private val _items: MutableStateFlow<List<ViewItem>> = MutableStateFlow(emptyList())
val metrics: StateFlow<List<ViewItem>> = _metrics

_metrics.value = _metrics.value.toMutableList().find { // some predicate }?.description = "a new title"

The

_metrics

won’t emit the new value (which is actually a change in the

ViewItem

object. Am I right or I am missing something here? And If I am right, in order to solve the above “issue” I need to use

Channel

or is there any other way with

StateFlow

?

Hei. @elizarov (apologies for tagging you directly) I wanted to get your rationale over

GlobalScope.launch { … }

I read this article https://elizarov.medium.com/the-reason-to-avoid-globalscope-835337445abc which makes sense, and I almost always use

withContext(AppropriateDispatcher) { … }

to offload heavy jobs. I have a ktor server that receives around 260 req/sec and logs request and responses while receiving and responding, along with actual response. This is done via an interceptor. Now I don’t care much about logging, so I was thinking to do something like

GlobalScope.launch(MDCContext()) { interceptor.request.log(...) }

so that logging is eventually done, but the interceptor can

proceed()

immediately. In fact, I was thinking to do this to pretty much every logging, Do you think it is a good way of doing the intention. What can be the consequences in regards to threads and CPU if a lot of logging suddenly starts offloading to GlobalScope ? Anyone can help me as well 🙂 Any and all feedback is much appreciated.