do you please have a minimal example?

Hi, is there a way to throw an exception on the next channel suspended

receive()

without closing the channel, thus allowing subsequent attempts to get a value from the channel? I assume

Channel

is not the right choice, but after reading the whole kotlinx.coroutines README, I did not find what I'm looking for.

Another question. Why

Mutex

is not reentrant? I'd love to have it for transactional stuff ("reliable writes" in BluetoothGatt). Is there an alternative? FYI, here's how I want to use it: https://gist.github.com/LouisCAD/88d06da6ae1caf04acbf6cd4fc1d5cac#file-gattconnection-kt-L56 EDIT: Added line of the relevant method in the link

Asad: I just wanted to try to convert the callback API of OkHttp into "synchronous calling style" of coroutines

@asad.awadia yeah but they're using CountDownLatch - this is what I expected coroutines will let me avoid 🙂

there’s blocking wait and blocking await

But if you need to access blocking I/O, do not do it in a coroutine.

The coroutine does not do the blocking. You have to do the blocking in a separate thread.

That awaiting is non blocking.

So with your count down latch example, the

latch.countDown()

etc. can not happen in the coroutine, it must be in a different thread.

@louiscad You can't have an actor (maybe with a buffer or conflated) receiving all requests, and handling what to do if there's no connection?

@louiscad I'd define

val connectionStatus = ConflatedBroadcastChannel<Boolean>(false)

to keep connected/disconnected status and then whenever I need to wait for it being connected I'd do

connectionStatus.consume { while (!receive()) { /* do nothing */ } }

@qwert_ukg

async

can also work if you (dangerously) want to also forget about potential exceptions

imo

async

shouldn’t be used if you don’t need result. Probably make sense to write some style guide for kotlinx.coroutines (especially for API). We have so many useful idioms and best practices even now

A friendly reminder: https://stackoverflow.com/questions/46226518/what-is-the-difference-between-launch-join-and-async-await-in-kotlin-coroutines

coroutines are a good way, Elizarov posted an example https://stackoverflow.com/a/46890009/3485324

What's the difference between

send()

and

offer()

when using

RendezVousChannel

apart from the fact that

offer()

is not suspended?

Hi, after upgrading to Kotlin 1.2.0 on Android, a gradle plugin that uses coroutines (also compiled with Kotlin version 1.2.0) and since this upgrade when I run a task from Gradle to run this plugin I get the following error: Caused by: java.lang.NoSuchMethodError: kotlinx.coroutines.experimental.DeferredKt.async$default(Lkotlin/coroutines/experimental/CoroutineContext;Lkotlinx/coroutines/experimental/CoroutineStart;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lkotlinx/coroutines/experimental/Deferred; Any ideas why? Thank you in advance!

Can a coroutine actor send to it’s own channel?

You can use

CompletableDeferred<Unit>()

as a latch. On one side you

await()

it, on the other you do

complete(Unit)

.

Do I understand correctly that there are no ways to have observable collection out of the box? So if I want observable list, I have to have either a channel holding either new copy of the list or incremental changes depending on the use-case?

my company needs a future type (on Java 7, so no

CompletableFuture<T>

. But we have mixed kotlin/java code. Does that mean we cannot use

Deffered<T>

?

I don’t need the bells & whistles of cancellation and such

Are you using coroutines in production? No problems (e.g. on old devices)? (Android)

Hi, just starting to ge my head around coroutines. Love them but have a question. I am using Channels as a queue between coroutines and would like to receive a message but timeout if no message appears within say 1 second. I am currently using

withTimeout(1000){ incoming.receive() }

to do this but it seems to be hanging rather than timing out. Am I missing something?

Hey, I'm just starting with coroutines as well. Is there a way to stop a coroutine from inside? Something like this:

fun main(args: Array<String>) = runBlocking {
    myFun { if (it == 10) return@myFun }
}

suspend fun myFun(call: suspend (Int) -> Unit) {
    for (i in 0 until 50) {
        call(i)
        println(i)
    }
}

, but the coroutine just keeps running. I also tried

coroutineContext.cancel()

on line 2, but that doesn't work either and throws an exception.

Maybe

fun suspend(block: suspend () -> Unit) = block

works?

i'm stuck on an issue where i'm going from an akka stream via function to a suspended function, but the suspended function isn't returning. I presume I'm doing something wrong, but don't know how to narrow the issue further. any tips? p.s. are there tracing facilities for coroutines?

private fun processMessage(record: KafkaMessage) {
    runBlocking {
        launch {
            handler.doSomething(record.data) // its implementation simply returns
            log.debug("2") // NOT CALLED
        }.join()
    }
}

can I use blocking calls (i.e. to sql db) on a "Cooperative single-thread multitasking" environment? see https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#cooperative-single-thread-multitasking