guys I cant believe this how can they executes 100000 sleeps(1sec) in a thread pool and the whole result only takes a bit more than 1 sec?!!? what kind of magic lays behind that!? 😱

@nkiesel Is this related to my

DynamicGraph

link on Twitter? Are you trying to run a partially ordered set in parallel?

@nkiesel sorry, not this week.. I'm on ICPC World Finals in South Dakota. Tune in to watch. Awards ceremony is going right now: http://icpclive.com

is firebase on the list for coroutines integrations?

No idea -

java.lang.NoSuchMethodError: No static method launch$default(Lkotlin/coroutines/experimental/CoroutineContext;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/experimental/Job; in class Lkotlinx/coroutines/experimental/BuildersKt; or its super classes (declaration of 'kotlinx.coroutines.experimental.BuildersKt' appears in /data/app/---/base.apk)
                                                                             at org.jetbrains.anko.sdk25.coroutines.Sdk25CoroutinesListenersWithCoroutinesKt$onClick$1.onClick(ListenersWithCoroutines.kt:284)

@deviant You ignore the resulting future (

Deferred

). That is why.

Hi! Why doesn't kotlinx.coroutines doesn't ship with documentation and source when adding the dependency? Using Android Studio with gradle. I wanted to know the difference between

launch(…) { … }

and

async(…) { … }

, but with no doc available in the IDE, it's really inconvenient. I mean, this translates to blind autocompletion, which partly defeats it's purpose

@wouterdoeland: can you elaborate please? Does not it work or what?

@nkiesel There is no need to overcomplicate

waiFor

just

waitFor(predecessors: Tasks) = predecessors.forEach { it.await() }

works just as fine

When running this

println("received update."); launch(CommonPool) { println("in pool"); //more code }

code on my desktop, it does print

received updated.

and

in pool

, but when running it on an Digital Ocean droplet it only prints

received update.

. Any reason why?

Also, can I override functions and make them suspend (in the parent class/library they are not suspended and not in Kotlin)

@groostav Coroutines make async logic simpler to express. To get benefits over other approaches from coroutines, your code has to have some suspensions (waiting for network IO, etc). You can do all the other stuff with coroutines too by simply replacing threads with coroutines, but you will not get any saving neither in terms of code size, nor in performance. In particular, parallelising CPU-bound workflows of the type that Mike shows there falls into that category.

ron's theory places quite some demands on the coroutine implementation. as far as i can see, kotlin's version does meet them, but i haven't looked at it extensively.

@groostav The documentation on

isDispatchNeeded

gives an answer: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/-coroutine-dispatcher/is-dispatch-needed.html There are lots of good explanations on the web as to why in JS world it is a standard to always schedule execution of async operations for later, as opposed to executing them immediately on stack (in short, it causes lots of subtle problems down the road that do not worth minor performance improvement it gives)

@groostav I can recommend this piece on why async has to be always async. It is about callbacks, but it applies to any style of async programming: https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/

I'm also wondering if it might be a good idea to allow coroutines to override

finalize()

to

resumeWithException

rather than allow for the "abandoned" coroutine phenomina. I just spent a fair bit of time discovering a way we could produce abandoned coroutines and replacing them with an exception flow such that nobody simply gets left hanging (a form of live-lock I suppose?)

verticalLayout {
            button("Delay").onClick {
                log("click begin")
                runBlocking {
                    log("delay begin")
//                    delay(30000L)  
                    Thread.sleep(30000L)
                    log("delay end")
                }
                log("click end")
            }
        }

guys,i’m a newbee in coroutine, i tried these piece of code, when change delay to sleep, an ANR was issued by system i want to know why delay does not issue an ANR and what is main thread doing when the delay clause is executing, would anyone be kind enough to explain this for me ?

I'm not saying it's a real problem for me 🙂 However, if I needed to send many messages to a channel/actor asynchronously, setting a large channel capacity +

offer

would be the first thing I'd think about. I tried

launch(parent-context) { ch.send(..) }

, but it's very slow.

📣 Btw, video from my “Introduction to Kotlin coroutines” talk is up: https://vimeo.com/221264980/b3ac7f9001 Slides are here: https://www.slideshare.net/elizarov/introduction-to-kotlin-coroutines

@groostav Why do you need it? Do you need the

context

?

@elizarov doesn't "exceptionally" translate as "исключительно" to Russian? If so, it's not a good term.

@elizarov Will the

pipe

function work like a mediator between the producer and consumer?

@groostav: the plan is to get rid of

CoroutineScope

completely and provide top-level val

coroutineScope

and

coroutineScope.isActive

extensions instead.

@louiscad I’d recommend the following workaround for your use-case in your fragment code:

val mapAsync = async(context, CoroutineStart.LAZY) { ... your async code here to get the map ...  }

Then you’d use it like this

fragment.mapAsync.await()

. It is not as clean as property delegate, but works just as fine (100% lazy and remembers the value after initialization)

Rule of thumb: coroutines are for asynchronous tasks that wait for something most of the time. Threads are for CPU-intensive tasks.

Just released Kotlin Coroutines for Retrofit v0.6.0 - https://github.com/gildor/kotlin-coroutines-retrofit/releases/tag/v0.6.0 available on jcenter and maven central it’s supposed to be the last release before merge to kotlinx.coroutines integrations. If somebody has any ideas about API changes before that, please message me or PR.

Slides from my SPTCC 2017 (http://neerc.ifmo.ru/sptcc/) talk on (some) Lock-Free algorithms that are used in `kotlinx.coroutines`library are here https://www.slideshare.net/elizarov/lockfree-algorithms-for-kotlin-coroutines

moved from #getting-started Any best practice to implement job queue in Kotlin using coroutines? Here is my code

val queue = LinkedBlockingQueue<Note>()
    var closed = false

    init {
        async(CommonPool) {
            while (!closed) {
                while (!closed && queue.isEmpty()) {
                    delay(50)
                }
                while (!closed && !queue.isEmpty()) {
                    play(queue.take())
                }
            }
        }
    }

I don't like

delay(50)

and I think it's not sufficient.

Not sure if it's okay to promote personal blogs here, but I've published a post about coroutines yesterday. Maybe someone's interested :) https://blog.simon-wirtz.de/kotlin-coroutines-guide/