hey guys. i have a question (which might be rather stupid). why does this test does not throw a TimeoutCancelationException?

doesnt work .. suspension function can be only called within coroutine body

would be nice to have some mockito addons for coroutine testing 🙂

@bitkid You may like this one as well for testing code that uses coroutines: https://github.com/Kotlin/kotlinx.coroutines/pull/297

Last night our meetup topic was Coroutines and I wanted to implement them in a json parse, but it's not as fast as I expected

val gson = GsonBuilder().create()
val jsonArray: JSONArray = responseJsonObject.getJSONArray("Value")

val parsedItemArray = List<Deferred<Item>>(jsonArray.length()) {
    async { gson.fromJson(jsonArray.get(it).toString(), Item::class.java) }
}

runBlocking {
    parsedItemArray .forEach { defered ->
        val item = defered.await()
    }
}

So I'm parsing an array of json objects in a JSON array using gson into a list of Deferreds. I call the parsing in an async, then I wait until they are all done. I call a timestamp before and after it's done the same code without coroutines runs faster

val gson = GsonBuilder().create()
val jsonArray: JSONArray = responseJsonObject.getJSONArray("Value")

val parsedItemArray = List<Item>(jsonArray.length()) {
    gson.fromJson(jsonArray.get(it).toString(), Item::class.java)
}

I was using a parallel class (found on stack overflow) previously with much better results

object Parallel {

    private val iCPU = Runtime.getRuntime().availableProcessors()

    interface LoopBody<T> {
        fun run(i: T)
    }

    fun For(start: Int, stop: Int, loopBody: LoopBody<Int>) {
        val executor = Executors.newFixedThreadPool(iCPU)
        val futures = LinkedList<Future<*>>()

        for (i in start until stop) {
            val future = executor.submit { loopBody.run(i) }
            futures.add(future)
        }

        for (f in futures) {
            try {
                f.get()
            } catch (e: InterruptedException) {
            } catch (e: ExecutionException) {
            }

        }

        executor.shutdown()
    }
}

I call it with this

val gson = GsonBuilder().create()
val jsonArray: JSONArray = responseJsonObject.getJSONArray("Value")

val parsedItemArray = arrayOfNulls<Item>(jsonArray.length())

Parallel.For(0, jsonArray.length(), object : Parallel.LoopBody<Int> {
	override fun run(i: Int) {
		parsedItemArray[i] = gson.fromJson(jsonArray.get(i).toString(), Item::class.java)
	}
})

With my above code, Serialized parsing takes 3 seconds, Parallel takes 1.5, Coroutine takes 3-4 seconds

exception handling

I've got a list of objects that have Deferred properties which produce some kind of reult, afteer result is produced, the Deferred is replaced by another (Completable)Deferred. Now I want to create a listener which will perform some action when any future is completed. I am trying to do so using

select

clause this way:

val job = launch {
            while (true) {
                select<Unit> {
                    stateHolder.forEach { state ->
                        state.future.onAwait {
                                // do something
                        }
                    }
                }
            }
        }

But it does not seem to enter the select clause even once. What am I doing wrong?

so my updated function is good i think

Crossposting: https://github.com/Kotlin/kotlinx.coroutines/issues/312

@elizarov can we make

CoroutineContext#DEBUG

field public and mutable? In android we usually rely on generated

BuildConfig.DEBUG

field.

if you tell me which API is necessary to wrap, I could take a look for the next version

Is there a more spread out way of writing complex actors?

Hi, can anyone point me to any coroutine koans repo?

Hey! I'm learning about coroutines and have a pretty simple question (I think). I want to do two tasks concurrently:

val first:  Deferred<Unit> = async { firstTask() }
val second: Deferred<Unit> = async { secondTask() }

first.await().let { doFirstStuff() }
second.await().let { doSecondStuff() }

In this example, will the

doFirstStuff()

always be called before

doSecondStuff()

? Or can

doSecondStuff

trigger as soon as

second

is evaluated (this is what I want to achieve)?

Why not just rewrite it like:

val first:  Deferred<Unit> = async { 
   firstTask().let { doFirstStuff() }
}
val second: Deferred<Unit> = async {    
    secondTask().let { doSecondStuff() }
}
first.await()
second.await()

Suspend constructor? %)

Anyone know if there is a Promise.all() equivalent for

Deferred<T>

?

just out of curiosity, can you switch the order of the tests

let's say I have 10_000 test cases which map to a float

result

. I want to quickly find a test case, where

result < c

, where

c

is a constant. Is there any way I can cleanly structure my code to achieve this?

I am trying to use coroutines with connections. However,

Jsoup

connections uses blocking (

Thread.sleep()

I think)... this effectively makes each coroutine the same as a thread. Is there anyway to turn these API `sleep()`s into `delay()`s?

nvm I got it—Java NIO

also a different question: I'm a little bit confused about what coroutine constructs have to be explicitly cancelled to free memory and what will be garbage collected automatically. Stuff like channels and jobs (outside a running coroutine) I assume will just get garbage collected without needing to call

close

or

cancel

on them?

Sorry if this has been asked a million times, but is there a coroutines equivalent to javascript’s

Promise.all

in the standard library? Something kind of along the lines of this… but better 😛

fun <T>all(list : List<suspend () -> T>) : Deferred<List<T>> {
    return async {
        list.map { async { it() } }
            .map { it.await() }
    }
}

I've been having some difficulty with debugging my coroutine code. When I set breakpoints within a coroutine, I am unable to see local variable using evaluate. I'm assuming I just don't get something in regards debugging coroutines.

Is this a good idea?

mutex.withLock(owner = coroutineContext) {
   // Some suspend calls
}

@louiscad thank you, but I was searching a method to do that if exists without changing my network layer.

How can I pass a compiler flag like -Dkotlinx.coroutines.debug when running an app in Android Studio?