@zokipirlo see the above thread, this code is broken no matter if contains is thread safe or not. think about this scenario:

launch(ioContext) {
	if (!mutableList.contains(something)) {
		modifyActor.send(Add(something))
	}
}
launch(ioContext) {
// Actor has not yet processed the 'Add' message, because it was busy processing other requests
	if (mutableList.contains(something)) {
		//We will not get here
		modifyActor.send(Remove(something))
	}
}

Any one else notice that

CoroutineScheduler

seems far too conservative about parking threads?

Limit-Breaker: I was Reading about Coroutines in Kotlin "Kotlin coroutines are stackless , they don't have their own stack" "Threads are managed by OS and Coroutines managed by Users " What does this mean ? How Kotlin coroutines manages to unblock thread while suspending the functions ?

Hi, I'm using kotlinx.coroutines with TornadoFx and the JavaFx artifact, and it worked fine, but today, it is not working but showing this in the logs:

java.lang.IllegalStateException: Module with the Main dispatcher had failed to initialize

(without cause logged). What could be the issue?

Good asynchronous people. Do we have a way to not use the Android Dispatcher for

Dispatchers.Main

when running on the test configuration (e.g. Unit tests)

Hi everyone, I’m having a bit of trouble with

runBlocking

and CoroutineScopes. I want to launch a coroutine in a scope with a combined

Job

for this coroutine to run until the job is cancelled. It works fine, but I would like to wrap it in a

runBlocking

(for unit tests purposes), but unfortunately the

runBlocking

doesn’t wait for the inner launch... Do you have any idea why ? Or how could I make it work somehow ?

Have anyone noticed / faced this https://github.com/Kotlin/kotlinx.coroutines/issues/878 ? And eventually have an answer about how to bypass that slow init by statically creating our own Android dispatcher?

Hi, folks. I've just wrapped android billing into coroutines https://github.com/lion4ik/BillingCoroutines . I would appreciate your code review. Feel free to come up with ideas and issues. 🙂

Hey. I’m going through the Coroutines docs and I’m a bit confused about the

.cancelAndJoin()

method. What is it good for? Why would I want to wait until the coroutine actually finishes the cancellation? I bet there is a pretty clear use case, but I just can’t see it.

Is anyone using Coroutines for Event Sourcing?

Hi, is there any chance some kind of a reconstructed stack will be available in debug when stopping at a breakpoint in a coroutine? I guess specialized tooling will be required for that, is that right?

Is it recommended to use coroutine methods marked with

ObsoleteCoroutinesApi

on our production apps? I'll like to use something around actors but worried about this annotation

Hi. I want to send data from one application point to another. I would like to use Channels for this. I use RendezvousChannel, but I always need to consumeEach so that I can receive updates on the next data transfer. In the documentation, the consumeEach method is marked as @ObsoleteCoroutinesApi. Maybe there is another way to get data?

Can I have airhorns go off next time I accidentally use

Thread.yield()

instead of

kotlin.coroutines.yield()

?

Hi. I used channels to transfer data from one application point to another (From one screen to another). When I call send and receive for the first time, everything works fine, but if I try to re-do send for the same channel, I can’t get the data by calling the receive method. I found a solution that needs to use consumeEach. And the truth is, if you use it, then when you re-send, the receive method returns new data. In this regard, the question is, what is the fundamental difference of consumeEach from other functions: consume, first, last and others. I give an example code

I have this warning all over the place polluting our build logs, to the point where circleci is making me download our build logs because they are too long:

This declaration is experimental and its usage should be marked with '@kotlinx.coroutines.ExperimentalCoroutinesApi'

Is there a way I can declare that we are using experimental coroutines api in the

build.gradle

, and thus get rid of all these warnings everywhere? Or am I forced to go to every file, and explicitly annotate it?

What is the best/official way to write a custom MainCoroutineDispatcher? I wrote one for SWT but requires use of internal and experimental API

Good or bad idea to use

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

when reading from Android's shared preferences?

When I add the following to all my submodules:

tasks.withType(KotlinCompile) {
    kotlinOptions.freeCompilerArgs += ["-Xuse-experimental=kotlinx.coroutines.ExperimentalCoroutinesApi"]
}

I notice I get the following error in modules that don't use coroutines at all:

e: Experimental API marker kotlinx.coroutines.ExperimentalCoroutinesApi is unresolved. Please make sure it's present in the module dependencies

Anyone know of a fix?

Hello ! Can somebody tell the difference between Async/Await in C# , JS and Async coroutines in Kotlin. I read the docs of both (Async/await in c# & Async in Kotlin ) . Both lets you do the asynchronous programming without blocking the thread. So except the syntax . Is there any difference? Is there any upper hand of Async coroutine in Kotlin

This message was deleted.

Does

runBlocking

exist for the sole purpose of bridging non-blocking with blocking code? If I have a java application that depends on a Kotlin library, would I be able to have the library support coroutines by wrapping the API functions with

runBlocking

, or are there other gotchas I need to know so the java application can take advantage of asynchronous code?

Question about CoroutineDispatchers and resuming suspension points: Say a coroutine has a context with the

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

which is backed by a pool of threads, let’s say “Thread-1” through “Thread-64". When a suspension point in a suspend function is reached while running in “Thread-4”, does the function always resume in the same thread, “Thread-4", or could it resume in any of the other threads of the thread-pool of

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

(it could be “Thread-35”)? I think it is the last option (could be in the other threads of the dispatcher), but I’m not sure … 🙂

Can we escalate this? https://github.com/Kotlin/kotlinx.coroutines/issues/858 I have a LOT of crashes

i'm paginating list and loading 5 items each time recyclerview scrolled to last , then using

coroutine

i'm getting more data for each item from network like below

private fun onItemsLoaded(videosList: List<BaseVideo>) {
        uiScope.launch {
            val videoAndData = getUserDataForEachVideo(videosList)//suspending function
            adapter.addData(videoAndData)
        }
    }

so here everytime whenever new 5 items loaded then

new

coroutine

is created, so here over the time it will increase created coroutines , i know that coroutines are light weight but is there any other way to solve this problem where i can create a single coroutine and then run my code inside that coroutine instead of creating new coroutine everytime

What's the best way to keep draining continuously a receivechannel, cancel whatever task the receiver is doing (if any) and start processing the latest messages as soon as they reaches the channel?

Is there a quick way to create a

ReceiveChannel

from an

Iterable

? à la

fun <E> Iterable<E>.toChannel() =
	GlobalScope.produce { forEach { send(it) } }

I'm trying to understand coroutines and I have a question: why does

c2

method hang here ?

I created a library for using coroutines with AWS SDKs. Any code reviews/input would be appreciated! https://github.com/bradynpoulsen/aws-sdk-kotlin-coroutines/