strange speedup in kotlin coroutines? - kotlin

Question

I have these two kotlin code snippets for measuring the startup times of threads.
First:
import kotlinx.coroutines.*
fun main() {
runBlocking {
for(i in 0..99){
val start = System.nanoTime()
launch {
val time = System.nanoTime() - start
println("Starttime: %,d".format(time))
}
}
}
}
This code starts by printing something in the range of 35.000.000, and goes through 100iterations where the value becomes larger and ends around 75.000.000.
Now if I run this code
import kotlinx.coroutines.*
fun main() {
runBlocking {
val list:MutableList<Long> = MutableList<Long>(100, {0})
for(i in 0..99){
val start = System.nanoTime()
launch {
list[i] = System.nanoTime() - start
}
}
delay(1000) // wait for all coroutines to have stored result
list.forEach{ println("Starttime: %,d".format(it)) }
}
}
This code is obviously faster, since the print statement is not included in the launch. But there is some other behaviour which is strange. It starts around 50.000.000, jumps directly to 17.083.000, and then slowly climbs back up to 29.507.300 where it ends.
So my questions is: why does the first piece of code deteriorate so fast, and quickly become slow, while the second code is able to be so much faster, and that it doesnt become slower over time as i add more coroutines?

Answer 1

You're making a little mistake of not preloading classes before measuring time so results are skewed. You should also print jobs index so you can see in what order jobs are actually completed.
I'd suggest modifying your code samples:
First:
suspend fun main() {
// dummy calls to preload classes before measuring
val s = System.nanoTime()
GlobalScope.launch { println("starting %,d".format(s)) }.join()
repeat(100) { i ->
val start = System.nanoTime()
GlobalScope.launch {
val time = System.nanoTime() - start
println("Starttime[$i]: %,d".format(time))
}
}
delay(1000) // wait for all coroutines to print result
}
Second:
suspend fun main() {
// dummy calls to preload classes before measuring
val s = System.nanoTime()
GlobalScope.launch { println("starting %,d".format(s)) }.join()
val list: MutableList<Long> = MutableList<Long>(100, { 0 })
repeat(100) { i ->
val start = System.nanoTime()
GlobalScope.launch {
list[i] = System.nanoTime() - start
}
}
delay(1000) // wait for all coroutines to have stored result
list.forEachIndexed { i, it -> println("Starttime[$i]: %,d".format(it)) }
}
First sample obviously "deteriorates" as you just pile up 100 jobs instantly while they take significant amount of time to access System.out to perform printing operation. You may also experience they most likely do not print [their index] in order.
Second sample is more or less stable because jobs don't perform any heavy operations so there's usually a free thread in Dispatchers.Default pool to execute launch block immediately.