coroutines.kt

package org.example

import kotlinx.coroutines.Dispatchers.IO
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import java.util.concurrent.Executors
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine

fun processInteger(i: Int): String {
    // blocks the whole thread! run it on IO dispatcher in a coroutine context
    Thread.sleep(1000)
    return "Done for $i"
}

suspend fun suspendProcessInteger(i: Int) = withContext(IO) {
    processInteger(i)
}

fun main() {
    val listOfThings = (1..10).toList()

    val results = runBlocking {

        val resultDeferreds = listOfThings.map {
            //async(IO) { processInteger(it) }
            async { suspendProcessInteger(it) }
        }

        resultDeferreds.awaitAll()
    }

    println(results)
}

// more functions!!

private val sharedExecutor = Executors.newCachedThreadPool()

fun processWithCallback(i: Int, callback: (str: String) -> Unit) {
    sharedExecutor.submit {
        val result = processInteger(i)
        callback(result)
    }
}

suspend fun suspendProcessWithCallback(i: Int): String {
    return suspendCoroutine { continuation ->
        processWithCallback(i) {
            continuation.resume(it)
        }
    }
}