kotlinlang #coroutines

parameters to launch, async, etc. What's the best way to wire up channels to cancel on coroutine completion after this change? Explicit try/catch in the coroutine? (Is there a discussion about this change anywhere I could read up on?) https://github.com/Kotlin/kotlinx.coroutines/commit/3049652ff5e3a23e35bcc82e28fb87936ed836ec

6 replies · 2 participants

igorvd

09/21/2018, 1:45 PM

someone have an guide showing how to migrate from coroutines 0.25.0 to 0.26.1 ? I understand that have some big changes, but things that usually worked before, aren't working now. I'm trying to get a result from a suspend function, inside another suspend function, without wrapping in any new coroutine, and it's not working... If I debug, I can see the right result in the

return

line on my second suspend function, but it never return to the first one...

2 replies · 2 participants

09/21/2018, 8:59 PM

in what repo is atomicfu 0.11.7-eap13? it's not in maven central or the eap repo. nor dev nor kotlinx...

3 replies · 2 participants

spierce7

09/22/2018, 3:58 AM

@elizarov Has the coroutine library been released in a format that can be pulled in with the new Kotlin multiplatform gradle plugin? https://github.com/h0tk3y/k-new-mpp-samples I'm trying to pull 0.26.1 manually for each source-set indepdendently but encountering gradle sync fails without good error outputs.

1 reply · 2 participants

littlelightcz

09/22/2018, 9:49 AM

Hi there, I am just getting my lib ready for the coming of 1.3 (I am using 1.3.0-rc-57), and just a little naming note - when I look into the Dispatchers object, there is Default and Unconfined. I wouldn't mind going lowercase here, since it's just a field, right? (not a subclass etc.) I remember I already proposed going with lowercased

io {}

pool as well (in some github discussions), so I am just re-throwing this idea again before the release decisions will be final (if they're not already) 🙂 .

6 replies · 2 participants

Nikky

09/22/2018, 10:27 PM

can i name coroutines ? so i see job-abc or w/e instead of coroutine#1234 when i enable debugging

➕ 1

2 replies · 3 participants

Nikky

09/23/2018, 12:27 AM

also something else thats weird, i am in a screenshare with friend, they have the issue that some coroutines work fine locally but break down once executed on their debian server, coroutines do not wait on the scope, they seem to just all start, and then the program closes they are on openjdk 1.8.0-171 on debian

6 replies · 2 participants

vaskir

09/23/2018, 10:39 AM

coroutineScope {
    (1..30)
        .map {
            async {
                print("offering $it...")
                queue.offer(it).await()
                println("offered $it")
            }
        }.awaitAll()
}

1 reply · 2 participants

Nikky

09/23/2018, 6:47 PM

it seems to have been something in ktor-client-okHttp taking its time to shut down which holds back the main function from closing

6 replies · 3 participants

gotoOla

09/23/2018, 6:53 PM

When I read the article I’m thinking the the implementation of CoroutineScope is more important when you do things such as Activitys in android etc. Our microservices are strictly backend and the dependency context of the application is created once during start so we don’t typically do “new MyService()”

3 replies · 2 participants

otakusenpai

09/24/2018, 5:12 AM

whats the current version of kotlin coroutines and how do i include it in my project ?

4 replies · 2 participants

Dominaezzz

09/24/2018, 1:08 PM

Out of curiosity, why isn't

runBlocking

in the standard library? Since you can suspend without kotlinx.coroutines, shouldn't you be able to at least block without it?

6 replies · 4 participants

gildor

09/24/2018, 2:44 PM

To test code in doStuff just test this function, do not test myMethod

👍 3

🤔 1

💯 2

23 replies · 2 participants

spand

09/25/2018, 12:17 PM

Trying to migrate to 1.3.0-rc-57 and 0.26.1-eap13 and I get errors for code that is basically:

synchronized(lock){
    implicitScope.launch {
        delay(1)
    }
}

I get an error that says: " The 'delay' suspension point is inside a critical section". Seems safe to me ?

13 replies · 3 participants

spand

09/25/2018, 12:23 PM

The same code when compiling in idea breaks with internal error mentioning

SuccessOrFailure

. I thought that had been renamed?

1 reply · 2 participants

darych

09/25/2018, 3:10 PM

Hi! I'm newbie in coroutines. I'm wondering how I can make Spring's RestTemplate work with coroutines? I'm going to check ktor's source code. But from my perspective, network intercation in RestTemplate is blocking and there will be no improvement with coroutines. Am I right?

7 replies · 3 participants

redrield

09/25/2018, 7:07 PM

is there a way to reset their state such that they can run again?

1 reply · 2 participants

kirillrakhman

09/26/2018, 12:46 PM

I'm just migrating to new scoped coroutines. In one case, I'm inside a

Fragment

which implements

CoroutineScope

. The default cancellation behavior is to cancel in

onDestroy

. But one specific coroutine I want to cancel on a different event, e.g. in

onDetach

. Should I create a nested scope or should I just manually cancel the coroutine when the event happens?

5 replies · 3 participants

elizarov

09/26/2018, 8:56 PM

📣 📣 📣

kotlinx-coroutines

version

0.27.0

is published — polishing structured concurrency, getting ready for release, fixing bugs, see for details https://github.com/Kotlin/kotlinx.coroutines/releases/tag/0.27.0

🎉 15

1 reply · 1 participant

nwh

09/26/2018, 9:15 PM

Is there a way to debug a coroutine's scope tree?

3 replies · 2 participants

enleur

09/26/2018, 9:16 PM

I see

currentScope

is deprecated now. How should we run launch inside

suspend fun

now? Something like this

CoroutineScope(coroutineContext).launch {  }

2 replies · 3 participants

rdhruva

09/26/2018, 9:54 PM

upgrading my android project to coroutines 0.27.0 pegs android studio 3.3 canary 12 to 300x CPU utilization.. is it a known issue?

9 replies · 2 participants

louiscad

09/26/2018, 9:54 PM

Now that

currentScope { }

is deprecated, should I use its implementation,

CoroutineScope(coroutineContext)

instead? I have some code relying on it:

suspend inline fun <E> ReceiveChannel<E>.doOnEach(
        context: CoroutineContext = EmptyCoroutineContext,
        noinline action: suspend (E) -> Unit
) = currentScope {
    launch(context) { consumeEach { action(it) } }
}

that would become:

suspend inline fun <E> ReceiveChannel<E>.doOnEach(
        context: CoroutineContext = EmptyCoroutineContext,
        noinline action: suspend (E) -> Unit
) = CoroutineScope(coroutineContext).launch(context) { consumeEach { action(it) } }

3 replies · 2 participants

gildor

09/27/2018, 5:30 AM

You cannot, because this function already have another receiver This is one of the main reasons why we need extension function with multiple receivers, please vote and add your use cases https://youtrack.jetbrains.com/issue/KT-10468

1 reply · 2 participants

gildor

09/27/2018, 5:32 AM

We have exactly the same function on own CoroutineScope implementation that we used before structure concurrency release, but we add this extension function as member of our custom CoroutineScope

1 reply · 2 participants

Martin Devillers

09/27/2018, 8:19 AM

I often find myself having to load a global resource asynchronously, where it only needs to be loaded once, but it could potentially fail. An example is the delta with the server time, so that I can implement an NTP. For those cases, I implemented a

DeferredCache

with an

await

method which when called: - if no coroutine to load the resource has been launched, it starts a new one - if a coroutine to load the resource has finished successfully, it returns its result - if a coroutine to load the the resource has finished with an error, it restarts a new one - if a coroutine to load the resource has been launched and is still active, it awaits its result My current implementation looks like this

class DeferredCache<T: Any>(
    private val coroutineScope: CoroutineScope = GlobalScope,
    private val block: suspend CoroutineScope.() -> T
) {
    private var deferredValue: Deferred<T>? = null
    private val deferredValueLock = Mutex()

    private val usableDeferredValue: Deferred<T>?
        get() = deferredValue?.takeUnless { it.isCompletedExceptionally }

    suspend fun await(): T {
        val deferredValue = usableDeferredValue ?: deferredValueLock.withLock {
            usableDeferredValue ?: coroutineScope.async(NonCancellable, block = block).also { deferredValue = it }
        }
        return deferredValue.await()
    }
}

Can you think of a more optimal solution? Anyone running into this scenario as well? Might it be worth adding a “standard” way to do this?

21 replies · 4 participants

aaverin

09/27/2018, 1:37 PM

With coroutines-android, when logging coroutine scope, is it possible to tell the difference between Android.Main dispatched coroutine and non-main dispatched coroutine?

4 replies · 3 participants

nerses

09/27/2018, 2:51 PM

hi, i have a question regarding new structured coroutines. In here it says https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/basics.md#scope-builder

The main difference between runBlocking and coroutineScope is that the latter does not block the current thread while waiting for all children to complete.

But when i run the example there the nested launch inside

coroutineScope

blocks the execution of the

runblocking

scope and the last

println("Coroutine scope is over")

is always printed the last. Am i getting it wrong? Or there is a mistake in the docs

3 replies · 2 participants

Title

nerses

09/27/2018, 2:51 PM

hi, i have a question regarding new structured coroutines. In here it says https://github.com/Kotlin/kotlinx.coroutines/blob/master/docs/basics.md#scope-builder

The main difference between runBlocking and coroutineScope is that the latter does not block the current thread while waiting for all children to complete.

But when i run the example there the nested launch inside

coroutineScope

blocks the execution of the

runblocking

scope and the last

println("Coroutine scope is over")

is always printed the last. Am i getting it wrong? Or there is a mistake in the docs

kingsley

09/27/2018, 2:55 PM

coroutineScope

exits only after all the scoped coroutines have completed. However, it doesn’t block any thread. Once execution is suspended in the

coroutineScope

block, the thread is free to do some other work until the block is resumed again continuing from where it left off

Did you read this yet? https://medium.com/@elizarov/structured-concurrency-722d765aa952

nerses

09/27/2018, 3:53 PM

ah ok, thanks @kingsley after rereading that blog post it makes sense now 🙂

👍 1

View count: 2