if the send must suspend for concurrency reason, in theory that could be done with CAS operation, without waiting on a lock or stuff like that

there is one, it's

offer

perfect, indeed it's exactly what I'd need

I am getting this error as soon as I open intelliJ

I am running on 1.2.50

the problem went away when i upgraded to 1.2.51 everything

How could I go about wrapping an API that uses callbacks so that I can use it in a coroutine-y way (suspend fun and stuff)

Ah, I found the bit for it in the kotlin-coroutines, sorry

Look at coroutines channels

I can only think of changing the whole Java codebase of LuaJ to Kotlin (via the automatic tool) and marking every

fun

with

suspend

am I on the right track?

Is this a bug?

fun main(args: Array<String>) = runBlocking {
  fun log(msg: String) = println("[${Thread.currentThread().name}] $msg")

  newSingleThreadContext("SINGLE-THREAD").use {
    launch(it) {
      log("Running in single-thread context.")
      withContext(CommonPool) {
        log("Running in CommonPool context.")
      }
      log("Should be back to running in single-thread context?")
    }
  }.join()
}

prints:

[SINGLE-THREAD @coroutine#2] Running in single-thread context.
[ForkJoinPool.commonPool-worker-25 @coroutine#2] Running in CommonPool context.
[kotlinx.coroutines.DefaultExecutor @coroutine#2] Should be back to running in single-thread context?

For dealing with database transactions, I understand using a thread pool is the best way to go, since the transactions are blocking. To make it suspension friendly, I have a dispatcher:

val DB = Executors.newCachedThreadPool(object : ThreadFactory {
	var i = 0
	override fun newThread(r: Runnable?) = Thread("db-${i++}")
}).asCoroutineDispatcher()

If I use it like this:

launch(DB) {
   val records = ...;
   // A
}

Will code in

A

be tying up threads from the dispatcher?

@nwh Yes, if A includes blocking calls

Is anyone using coroutines with Kafka consumers? I've run into various issues, which I've tried to summarize here: https://issues.apache.org/jira/browse/KAFKA-7143.

Hello everyone, I'm playing with the `WorkManager`from the Android jetpack... I'd like to call some suspend functions inside of it, but the

Worker

expects a return value, so I can't just use the

launch

dispatcher. I'm using the

runBlocking

dispatcher to be able to call the suspend functions... Is this the right way to go? Here's an example:

override fun doWork(): Result = runBlocking {
        //call some suspend functions
       return Result.SUCCESS
    }

Thanks!

yes

Ok, thank you

does anybody know if the

Mutex

class in kotlinx.coroutines preseves locking order? In other words, if two jobs get suspended on a mutex, when the mutex is released will the first job to acquire the lock always go first?

its implementation delegates to

LockedQueue

, which implies queueing behaviour...

I'm a bit confused on channels. If I want to execute a task that is reporting progress back, do I create a channel and give it to my task function? Is that a good use for a channel?

if you want to emit events and consume them somewhere else, sure. you can either give the channel to your task function or have the task function return a channel

Yeah, that's what I want to do. Is there a certain advantage to those two options? The task function has mutable data, so I feel like an actor is appropriate, as I brought up earlier

actor is fine, but the channel it returns is for pushing events to it, so you’d need to provide a channel to the actor for it to report progress

@nwh uploaded a file:

A file was commented on

A file was commented on

A file was commented on

hmm, so along similar lines, I've got an object which, at construction time, makes a db call. I think, just idiomatically, I should have it use the async db which means in a property initializer I want to call a suspend fun. Now, in any reasonable situation this DB query will complete quickly, but, contractually, it can suspend for as long as it likes. Given that I wrote this little function:

and its use looks like this:

class MyServiceObjectThatMakesDBQueryAtInitialization(db: AsyncMap<UUID, Model>) {
  val modelObject = fastSuspendingInitializer { db.lookupInitialValue(key) }
}