Is there any reason to use

coroutineContext

with

withContext

?

atomicfu seems like good fit but what difference it has with Java's

Atmoic*

what’s the recommended way of doing something like this:

fun refreshData() {
        networkStatus = Status.ACTIVE // class member
        launch(CommonPool) {
            asyncAwait {
                remoteSource.fetchData().forEach {
                    roomDatabase.dao().insertData(it)
                }
                networkStatus = Status.INACTIVE
            }
        }
    }

i’d like to be able to unit test that the status is updated while the coroutine is running

Hi all. Need some help. What is the best way to return result of Listener callback function as result of my function which create it? Should I use channel to achive this or something like that?

fun someFunction() : SomeResult {
    val someObj =  SomeObj(SomeListenr { result ->
              SomeResult(result) // <- WANT THIS
        }
    )
    someObj.start()
}

Now I want to combine these two so I can expose another channel of

data class Person(val userName : String, age : Int)

However that

increasePortionCount

does not emit

I

launch(coroutineContext +IO) { channel.consumeEach { ... } }

. I feed the channel from another coroutine that runs every 15s, and in the

consumeEach

i do a network send (through a cpp library). This works fine for a couple minutes but eventually this coroutine stops executing and the cpu usage of the process goes from .02% to 70%. This is on a desktop. If I remove the

IO

and use the

CommonPool

it works fine. There are no errors or exceptions, the coroutine just stops and the cpu goes nuts. Is there anything I can do to try and figure out whats happening?

This test doesn't seem to execute. Nothing is outputted to the console except a Jest async timeout error message.

does anyone know how

suspendCoroutineUninterceptedOrReturn

or

intercepted

is generated in coroutine library? I’m confused about why some core functions are auto-gen… Any specific reason?

@Dico thanks for your answer! Actually i don’t understand Kotlin’s intrinsic very well, are the intrinsic functions platform-dependent?

is there a function to iterate over Flux in a coroutine context? Something like this:

someFlux.forEach {
   val result = callAnotherSuspendingFunction(it)
   doSomethingElse(result)
}

I have a unit test that calls a method with a

launch(UI)

in it, but I'm getting the following message

java.lang.NoClassDefFoundError: Could not initialize class kotlinx.coroutines.experimental.android.HandlerContextKt

So I'm curious about something: I'm trying to create a way so that different threads take input but only one thread is active at a time and I can switch between the threads and whatever input is taken goes to that thread. I'm not quite sure how to do it. I kinda did it using the JDK Thread api but it's not quite working out as well as I was hoping cause I need to keep input coming in until the active thread is changed and then the input is sent into the new active thread. I tried to look into coroutines but that only confused me even more. Any ideas?

the second last link on this page 404s, but I'm not sure what it's meant to point to: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/is-active.html

Hey :android: developers, here are 2

coroutineScope

extensions for

Lifecycle

and

LifecycleOwner

(that you can use in AppCompatActivities, Fragments, LifecycleServices...) for changes in kotlinx.coroutines 0.26.0: https://gist.github.com/LouisCAD/58d3017eedb60ce00721cb32a461980f#file-lifecyclejob-kt-L30

Can someone help me understand why I cannot replace

awaitAll(one, two)

by

one.await(); two.await()

in this code?

I'm trying the new kotlinx 0.26.0 toys, I struggel on something. I had a

Job

that I used as a parent for coroutines in this class. At some point I did a

job.join()

to make sure all operations were over. Now, I made this class implement

CoroutineScope

, I run some operations in

launch(Dispatchers.Main+job)

But

job.join()

is not effective anymore, and I cannot use

coroutineContext[Job]

for it. How should I do to have a 'global'

Job

which I could use?

Why is the

JavaFx

dispatcher not an extension property on

Dispatchers

?

Is there a 0.26.0-eap13 version of kotlinx-coroutines somewhere? I cant seem to find it and I was having immense fun previewing all the new goodies, why stop now!

i feel extremely spoiled by the source links on the stdlib documentation and would love them on the coroutine docs 😁

I used python before, and I converted one of the http servers that I had into async/await app, I used async libraries like aiopg or aiohttp. But say I have jdbi/jdbc based app, how do I convert it into async using coroutines without an async library or spawning any additional threads?

Hi! I have a question about coroutines. Right now I’m looking into building a load/pressure-test tool and I am using the ktor http client to execute like 1000 concurrent request towards another service. So far this seems to work out pretty well but I wanted to get some input from here if there are any gotchas I should watch out for Right now I am just using the commonpool (at least in my code and if I understood it correctly ktor-client will do the same) and it feels like there should be some performance hit somewhere were I spawn like 1000 tcp-connections on only cores-1 threads?

@elizarov I must say this article of yours https://medium.com/@elizarov/structured-concurrency-722d765aa952 scared me a lot about the way Kotlin is developed. All these months coroutines were out we were being convinced that the "experimental" flag is just an unfortunate naming. That they are pretty much close to being stable and fully thought out yet the article hints that you truly had no idea what you were getting into. I think the changes proposed in the article are last-minute and quite drastic. How are we supposed to be comfortable about adopting coroutines now? What if you made a huge mistake somewhere again?

Unfortunately, this example is wrong on many levels in very subtle ways.

Seriously? So all these talks were full of completely wrong examples? And you just found out? It's not like these concepts are completely new to computer science, why not take more inspiration from other languages such as

clojure.async

?

Hey guys. I’m getting error:

ava.lang.VerifyError: Bad type on operand stack
Exception Details:
  Location:
    app/Main$main$1$1.doResume(Ljava/lang/Object;Ljava/lang/Throwable;)Ljava/lang/Object; @1347: invokespecial
  Reason:
    Type 'java/util/Collection' (current frame, stack[2]) is not assignable to 'app/Main$main$1$1$doResume$$inlined$run$lambda$1'

I had a class that created a

newSingleThreadContext

and was passing that to

launch

. Is the right way to do this to now create a

CoroutineScope

that encapsulates that dispatcher, and then call

launch

with that scope?

replaced my cached thread pool dispatcher with

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

, now it cuts unused threads instant, but consumes more cpu

Having this method:

fun setup() {
        if (!requiresMigration()) {
            launch { regularPaymentSetup.setup() }
        } else {
            launch { migrationPaymentSetup.setup(it) }
        }
    }

How to unit-test that regularPayment is executed?

launch

starts a new coroutine and test fails

without explicitly writing an actor for every handler