from my understanding the first

async

should get cancelled after the exception since they are in the same scope.

Consider the following scenario: - High-latency HTTP requests, done using the Apache Async Client - Coroutine that "launches" multiple requests using

async

, obtaining

Deferred

objects - Coroutine then cancels one of those

Deferred

objects. 1) How can such a

cancel

trigger a cancellation on the pending HTTP request? The Apache Async Client has a way to cancel requests, however since there isn't any thread actively monitoring the

isActive

, I need to "link" the

Deferred

cancel with the pending request cancel. For instance, in .NET the

CancellationToken

as a

Register

method to register an action to be performed. 2) Also, if the coroutine decides to ignore the cancellation (e.g. it is to late to cancel the HTTP request), how can we observe that on the

Deferred

? What I'm observing is that the

await

will throw the

JobCancellationException

even if the

cancel

is ignored.

I created a jvm project and used coroutines version 0.30.1-eap13 with kotlin 1.3.0-rc-146. When I spin up my main method a basic coroutine, i get the following exception: Exception in thread “main” java.lang.NoClassDefFoundError: android/os/Looper at kotlinx.coroutines.android.HandlerDispatcherKt.<clinit>(HandlerDispatcher.kt:60)

why exactly is it looking for android class?

We have two versions.

0.30.1

for the people still on experimental (Kotlin 1.2) coroutines, and

0.30.1-eap13

for people who are playing with RC of Kotlin 1.3 where coroutines are no longer experimental

Can we get a hotfix for kotlinx.coroutines requiring 1.3.0?

The question really comes down to what you mean by "running in parallel"... do you consider suspended coroutines to be "running"? Or do you only count active coroutines currently executing on thread as "running"?

Maybe that's what you're looking for?

Hi! I am a newbie to coroutines. Are there any recommendations as to when to use coroutines and threads?

If I wanted to start some block as a long running process with multiple `async`/`launch`, should I use

withContext

?

withContext(GlobalScope.coroutineContext) {
  async {
  }
  launch {
  }
}

Is there example of other example? E.g. when coroutines help, and that not involve running same task with different data (sequentially/async)?

Would it make sense to have an inspection that warns when you have a suspending function that's an extension on CoroutineScope?

I don't understand why

currentScope

is deprecated. For example:

suspend fun httpGetAsync(): Deferred<String> = currentScope {
    async {
        // ... Do HTTP GET
    }
}

suspend fun main() {
  coroutineScope {
    val request1 = httpGetAsync()
    val request2 = httpGetAsync()
    
    println("${request1.await()} - ${request2.await()")
  }
}

If

httpGetAsync

was using

coroutineScope

, it means that

request2

will be filled when

request1

is completely done.

I mean, anything is better than a 5-word name that we have now. How about Delegates.fixedPool?

Are there any really good readings on using channels and actors? Explaining basics, examples, use cases, etc

I want to execute the coroutines in the for loop in parallel and when all complete I want

print(5)

to run. how should I go for doing this? the current code I sent runs the coroutines in loop parallel but

print(5)

does not wait for completion of the others.

if I have a Sequence from buildSequence, is there a way to collect all the elements it's already yielded and not care about anything else

Conceptually yes, but the second code is hot, too. Coroutine still runs. For an example of a cold stream try

sequence { }

. It is truly cold. But it is synchronous. We don’t have async cold streams yet.

How can I support cancellation within a

suspend

function? If I don't use

launch/async

etc to launch anything

I don't quite understand the contexts. For example, if I remove the runBlocking{} from the following code, it runs fine w/ the "done blocking" running in some random worker thread. But w/ the runBlocking{}, and that block never exits. I'm trying to run all the coroutines the main thread. code :

fun main(args : Array<String>) {
    var taskHandle:Continuation<Unit>?=null

    runBlocking { // If I run in this context, this block never exits.

        launch {
            while(true) {
                println("about to block")
                val retVal = suspendCoroutine<Unit> {
                    taskHandle = it;
                }
                println("done blocking.. on thread : ${Thread.currentThread().name}")
            }
        }
        println("done launching")
    }

    println("all coroutines blocked, do work...")

    repeat( 10, {
        Thread.sleep(ThreadLocalRandom.current().nextInt(2000) + 500L)
        taskHandle!!.resume(Unit)
    })
}

I see the coroutines-nio package has been removed recently. Any reason for this - is there an alternative?

Hi, I am new to kotlin and just started using Coroutines. I have few doubts. 1. If Coroutines is a language feature then why do we need to add dependencies? 2. How can I try latest 1.3 RC version in Android Studio? I tried following (and of course at its right place)

// Downloaded 1.3. early preview plugin of Kotlin for Android Studio

ext.kotlin_version = '1.3.0-rc-46'
// ext.kotlin_version = '1.3.0-rc-57'
maven { url '<https://dl.bintray.com/kotlin/kotlin-eap>' }
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.1") {
        exclude group: "org.jetbrains.kotlinx", module: "atomicfu-common"
    }
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.1'

Above setup giving me error

No route to host (connect failed)

3. What is working for me is just

ext.kotlin_version = '1.2.71'

implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.1") {
        exclude group: "org.jetbrains.kotlinx", module: "atomicfu-common"
    }
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.1'

Please guide me in the right direction. Thanks.

For (1) coroutines need core support for primitives. Same thing is done in the .Net JVM. The library is the API on top.

📣 📣 📣

kotlinx.coroutines

version

0.30.2

. Release contains fixes for issues with

Dispatchers.Main

and various improvements. Full changelog: https://github.com/Kotlin/kotlinx.coroutines/releases/tag/0.30.2

we do not need to create our own threads in Android for any reason?

@Rohit Surwase I don’t see any common reason even without coroutines create own threads on Android if you not a library author (usually you use ThreadPoolExecutor or some high level primitives) All those cases (1-3) are covered easily by coroutines and provide much better API without drawbacks. Especially if 1 and 2 have async api

But as standalone coroutines are deprecated what other alternatives do we have apart from GlobalScope

What do you mean? GlobalScope is direct successor of old standalone coroutine builders and provides the same lifecycle. But usually you don’t need it, use CoroutineScope everywhere where it’s possible to do

has examples about

runBlocking{ }

and

GlobalScope.launch( )

only

It’s just for simplicity of examples, docs has actually a lot of different examples, not only runBlocking or GlobalScope

shouldn't you file that on the kotlinx library? doesn't seem related to the language or stdlib

hi, i want just a simple

parallelStream

equivalent in kotlin.. does this make sense?

runBlocking {
   myItems.map {
    GlobalScope.launch {
       // do something
    }
   }.forEach { it.join() }
}

// now do something with all items