can anyone explain why this prints an uncaught exception to the console after 5 seconds? if I don't cancelAndJoin() the job, it acts like I expect. but the exception escapes the

GlobalScope.async

if the job `await()`ing it was cancelled. https://gist.github.com/kevinherron/37155732ccd4c0587a69a9d86e16b448

what's the advantage of coroutines over jvm threads? in js do they work as workers? what happens when you compile to native?

@ursus Moving discussion to coroutines, otherwise too many offoptic for this thread https://kotlinlang.slack.com/archives/C09222272/p1544765551091900?thread_ts=1544517238.067400&cid=C09222272

i've simplified, can anyone explain why this leads to an uncaught exception logged to console?

fun main(args: Array<String>) {
    val job = SupervisorJob()
    val scope = CoroutineScope(job + Dispatchers.Default)

    val deferred = GlobalScope.async(Dispatchers.Default, start = CoroutineStart.LAZY) {
        delay(5000)
        throw Exception("boom")
    }

    scope.launch {
        try {
            deferred.await()
        } catch (e: Exception) {
            println("error awaiting: $e")
        }
    }

    runBlocking { job.cancelAndJoin() }

    Thread.sleep(10000)
}

So you're cancelling a coroutine that is waiting, and thus expecting no error to be logged when the exception is thrown

Hello, About the JS implementation of

kotlinx.coroutines

. What is the base? I suppose

Deferred

is internally using

Promise

, but what about

Job

? Is it working with

Worker

?

How do I cancel long running operation when a couroutine is cancelled ? I know I can somehow use

isActive

, but here I would want to provide some kind of

onCancelled

callback. (here when I do cancel process is still present when doing

ps aux

)

Is there any way to get an exception that was caught in

produce

on the receiving end (apart from a sealed class, all I need is a Long progress value, and it's a pity to have to box/unbox them unecessarily)?

I am reading coroutines keep and there is a line that doesn't make sense to me:

It is a mix between a set and a map. Its elements have keys like in a map, but its keys are directly associated with elements, more like in a set.

But sets don't have keys, do they? And maps have their keys directly associated with values? Am I reading it wrong?

I have a callback receiving progress on downloading part of a file, I want to accumulate the progress of all the parts being downloaded to show progress in an Android app, do I really need that channel to send the results? Is there any better way to accumulate these results with a channel (maybe without the AtomicLong)?

Is there something ready-to-use for Throttling (skip some events for a while and handle only last one)? 🤔

Do coroutines safely prevent memory leaks? I’d assume so, but if that’s the case I think that it would be a good idea to state it more explicitly in the documentation.

Me again 🙂 This time I’m confused by some behavior involving

withContext

and

CompletableDeferred

.

val queueListener = launch {
        while (isActive) {
            // do something
        }
    }

    Runtime.getRuntime().addShutdownHook(Thread {
        <http://logger.info|logger.info> { "Cancellation requested" }
        queueListener.cancel()
    })

    queueListener.join()
    <http://logger.info|logger.info> { "Exiting program" }

why would “Exiting program” never show up? are there any other way to do it? I am also considering channel that sends some cancellation event. But what wold be the better way to handle this?

Are

actor

send channels automatically closed at the end of the

coroutineScope { }

that they're declared in?

I assume so

📣 📣 📣 I am happy to announce

kotlinx.coroutines

1.1.0-alpha! This is a major release with two new modules, a lot of improvements in testability and debuggability, various performance improvements and bug fixes. Changelog: *

kotlinx-coroutines-test

module with testable

Dispatchers.Main

*

kotlinx-coroutines-debug

module with debug agent to track and debug active coroutines * Stacktrace recovery mechanism that provides additional coroutine-based stacktraces in exceptions (enabled in debug mode) *

MainScope

and

CoroutineScope.cancel

methods for simpler integration with structured concurrency *

CancellableContinuation

race between

resumeWithException

and

cancel

is now not treated as an uncaught exception *

Dispatchers.Default

CPU consumption in idle state is reduced *

JavaFx

dispatcher initialization bug fixed Full changelog: https://github.com/Kotlin/kotlinx.coroutines/releases/tag/1.1.0-alpha

Hi, I have method with a callback, that will be called more then once. how to wrap it into coroutine?

Hey, have a question about `Job#invokeOnCompletion`… Is it true that after calling

cancelAndJoin

completion block is not guaranteed to be executed right after

cancelAndJoin

have completed? Tried to add some logging to see jobs actually finished

is there a built in construct for a suspending

lazy

?

Does any one have unit test recommendation for testing coroutine launched from Android's ViewModel scope? I'm able to pass a Unconfined dispatcher from unit tests to work around the Main looper uninitialized case. However, mockito verify fails as expected call and actual call differs in continuation

inject your dispatcher into the `ViewModel`’s constructor

thread here

I’m a bit confused here. I’m following this talk from Christina Lee from Droidcon around coroutines and trying to migrate my sample app from Rx following it. My question is, if I define the coroutineContext using the Main dispatcher by default, when I call

launch {}

am I not running the code inside on the main thread?

ok she probably missed it then and it was confusing me a bit, thanks for the help

that’s the thing I don’t. If I remove all the

withContext

and leave the

launch

as it is, and with the base context defined as Main + job it works just fine

Is there a type of channel that gives you an exclusive "lease" to an element until either a) the worker acknowledges it should be removed or b) a time out is reached that returns the element back to the front of the channel? (similar to Amazon's SQS)

@elizarov Is it possible to use the coroutine context to hold other information, such as a database connection that follows a request through the server? I can think of several instances where it would be nice to to use a coroutine context to intrinsically hold certain pieces of data to follow an async request.

What is the proper way in a simple suspend function to check if it's running inside a job and if that job is cancelled?