kotlinlang #coroutines

suspend fun <T> ReceiveChannel<T>.consumeThrottled(throttling: Long, action: (T) -> Unit) {
    var timestamp = 0L
    for (data in this) {
        if (timestamp + throttling < System.currentTimeMillis()) {
            timestamp = System.currentTimeMillis()
            action(data)
        }
    }
}

is there a proper way?

rogeralsing

07/12/2017, 6:30 PM

Some progress on my Proto.Actor for Kotlin coroutines: https://twitter.com/RogerAlsing/status/885204378692579328

janvladimirmostert

07/16/2017, 8:44 PM

Quasars gives you the option to handle Futures as fiber-blocking Futures instead of thread-blocking Futures http://blog.paralleluniverse.co/2014/08/12/noasync/ Can something similar be done with Coroutines or is this where the Quasar byte-code instrumentation has an advantage over coroutines ?

ait

07/18/2017, 7:40 PM

Hi! I can not figure out how to implement method of 3rd party interface as suspendable when I know that I will call it in suspendable context. What I need is some way to access CoroutineScope of running coroutine (I have some useful data in there) Any hints? I imagine something like ThreadLocal but did not find anything in API.

elizarov

07/18/2017, 8:25 PM

@ait There are two choices you have: You can either

launch

(fire and forget a new coroutine) or do

runBlocking

(to blocking invoking thread while the coroutine is running)

galex

07/20/2017, 12:41 PM

Hello, I’ve got a question about coroutines and if what I’m doing is counter-productive: I’ve got 111 urls to download and used coroutines with async {} to do it in parallel. By using CommonPool it takes 10 seconds but by using async(newSingleThreadContext()) per url I get to 6 seconds, almost twice as fast! It’s a gradle plugin meaning a few seconds after downloading all the data the program finishes so I am not worried about the number of threads. Does this makes sense to do it the way I did or is there a better way to be faster while using less threads?

groostav

07/20/2017, 9:21 PM

nope, update to that lib, still no good.

rogeralsing

07/20/2017, 11:37 PM

this is bloody insane.... our Skynet benchmark runs at 350 ms now... thats twice as fast as Erlang.....

rogeralsing

07/23/2017, 2:38 PM

I was more thinking if there was any extra weight to the Job object, if there was a lighter version of the same thing, which just schedules but does not allow for any control of the outcome

elizarov

07/24/2017, 1:50 PM

📣 📣 📣

kotlinx.coroutines

version 0.17 is released. It has a new

CompletableDeferred

primitive;

Job.join

and

Deferred.await

are waiting for coroutine’s execution on cancellation;

CoroutineScope.context

is renamed to

coroutineContext

and more. A full list of changes is here: https://github.com/Kotlin/kotlinx.coroutines/blob/master/CHANGES.md

🎉 11

❤️ 2

👍 10

rafal

07/24/2017, 2:03 PM

Is there somewhere an example of using "virtual time" in

delay

in tests?

rogeralsing

07/24/2017, 2:30 PM

Should the

kotlinx.coroutines.experimental.TimeoutException

really be private? I can catch CancellationException which is the base, but still?

omarkj

07/24/2017, 8:28 PM

Are there any other pools that ship with coroutines than the CommonPool? The common pool is backed by ForkJoinPool which unfortunately isn’t great for I/O intensive tasks where most the time is spent waiting.

feroz_baig

07/26/2017, 8:11 AM

fun main(args: Array<String>) = runBlocking {
            val job = launch(CommonPool) {
                var nextPrintTime = System.currentTimeMillis()
                var i = 0
                while (i < 10) { // computation loop
                    val currentTime = System.currentTimeMillis()
                    if (currentTime >= nextPrintTime) {
                        println("I'm sleeping ${i++} ...")
                        nextPrintTime += 500L
                    }
                }
            }
            delay(1300L) // delay a bit
            println("main: I'm tired of waiting!")
            job.cancel() // cancels the job
            delay(1300L) // delay a bit to see if it was cancelled....
            println("main: Now I can quit.")
            }

Why is the job not cancelled after calling it explicitly?

pilgr

07/26/2017, 12:25 PM

How can I handle exception throwing in bg task after Kotlin coroutine is canceled? For now, this leads to app crash. https://stackoverflow.com/questions/45326818/cant-catch-exception-throwing-after-kotlin-coroutine-is-cancelled

rafal

07/26/2017, 4:22 PM

that was stupid idea 😛 I've reposted this issue directly to mockito repo (https://github.com/mockito/mockito/issues/1152 )

groostav

07/27/2017, 6:26 AM

@voddan at least in principal thats what I'm looking for. What might be important is an efficient way to compute

StackTrace

feroz_baig

07/27/2017, 11:04 AM

Why

Mutex

is slower than

ReentrantLock

rafal

07/27/2017, 12:02 PM

channel.consumeEach {
   if(it.sth()){
     doSth()
  } else {
     // stop consuming - break out of consume
  }
}

kingsley

07/27/2017, 9:05 PM

future {}

doesn’t return a deferred. It returns a standard

CompleteableFuture

and

await

is simply an extension function on top of it

rogeralsing

07/27/2017, 9:40 PM

Can I get hold of the current ScheduledExecutorService inside a susped fun ?

voddan

07/31/2017, 11:57 AM

Is it only me, or try.kotlin.org does not support channels? I get

java.security.AccessControlException: access denied ("java.util.PropertyPermission" "kotlinx.coroutines.debug" "read")

when running code with

import kotlinx.coroutines.experimental.channels.*

kevinherron

08/03/2017, 9:22 PM

@elizarov at the end of your talk you mention that you’re working on an IO library - is that work happening in the open anywhere?

feroz_baig

08/05/2017, 8:14 AM

Anko's

bg

vs Kotlin

async

? Can somebody help me in this

elizarov

08/08/2017, 2:52 PM

📣

kotlinx.atomicfu

version 0.1 was released. This is an utility library that enables writing efficient and idiomatic Kotlin code with atomic variables, CAS, etc, without having to write companion objects with

j.u.c.a.AtomicXXXFieldUpdater

instances. It is limited for now (only Maven projects are supported), but that is sufficient to use it in implementation of

kotlinx.coroutines

(next version will use it). It is currently published to a separate Bintray repository and will soon be synced to JCenter. More details here: https://github.com/Kotlin/kotlinx.atomicfu/blob/master/README.md

:kotlin: 3

👍 6

elizarov

08/09/2017, 5:20 PM

It is not hard to follow certain patterns to make sure your code is cancellable: * If you code is like “do something, delay, repeat”, the cancellability comes via

delay

* If your code is some CPU-heavy stuff, then you must rememeber to check

isActive

periodically * If your code is build with

generate

actor

builder, then you get cancellability “for free” by the virtue of the fact the coroutine’s lifecycle is integrated with lifecycle of the corresponding channel (but you still have to keep in mind CPU-consuming part if you have any of that)

kevinherron

08/10/2017, 12:40 AM

@elizarov eap of the kotlin plugin or IDEA itself? stepping doesn’t work in the latest release version of IDEA + kotlin plugin

elizarov

08/10/2017, 7:38 AM

@anthonyeef If you are using

kotlinx.coroutines

library, then its

async

function returns a

Deferred

object that represent the future result of this asynchronous operation: https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental/async.html

mikehearn

08/10/2017, 2:36 PM

wrt atomicfu - how does it relate to VarHandles? Seems similar in concept, albeit with nicer syntax?

aaverin

08/10/2017, 2:46 PM

Hello guys. Got a following situation: AWS m3.large instance = 2CPUs, meaning 1 thread in CommonPool Have a bunch of services that look like:

fun getData() = async(CommonPool) {
  //do some network
  async(CommonPool) { //do some more parallel network }
  .await() //and process results all together
}

Let’s say 3-5 of such written services are called at the same time in parallel by users. Could this lead to any problems?

Title

aaverin

08/10/2017, 2:46 PM

Hello guys. Got a following situation: AWS m3.large instance = 2CPUs, meaning 1 thread in CommonPool Have a bunch of services that look like:

fun getData() = async(CommonPool) {
  //do some network
  async(CommonPool) { //do some more parallel network }
  .await() //and process results all together
}

Let’s say 3-5 of such written services are called at the same time in parallel by users. Could this lead to any problems?

kingsley

08/10/2017, 2:50 PM

Perhaps you could create your own thread pool context.

CommonPool

isn’t particularly suited for long blocking IO operations. Also, since it is (single?) and blocking, it’s clear why time outs will happen more often

View count: 2