Using a bit of java.util.concurrent with Kotlin

ThreadPoolExample.kt

// basic example of executing tasks in parallel

fun main(args: Array<String>) {
    val strings = listOf("a", "b", "c")
    val printStringTasks = mutableListOf<Callable<Unit>>()
    strings.forEach { printStringTasks.add(Callable<Unit>({
        println("starting task: $it")
        Thread.sleep(2000)
        println("finished task: $it")
    }))}

    val threadPoolExecutor = Executors.newFixedThreadPool(3)
    threadPoolExecutor.invokeAll(printStringTasks)
    threadPoolExecutor.shutdown()
}

// creating an object with results of a calling a list of Callables in parallel

import java.util.concurrent.Callable
import java.util.concurrent.Executors

fun main(args: Array<String>) {
    val strings = listOf("a", "b", "c")
    val printStringTasks = mutableListOf<Callable<String>>()
    strings.forEach { printStringTasks.add(Callable<String>({
        println("starting task: $it")
        Thread.sleep(2000)
        println("finished task: $it")
        return@Callable it
    }))}

    val threadPoolExecutor = Executors.newFixedThreadPool(3)

    data class ThreeStr(val a: String, val b: String, val c: String)

    val awaits = threadPoolExecutor.invokeAll(printStringTasks)
    
    val ts1 = ThreeStr(
            awaits[0].get(),
            awaits[1].get(),
            awaits[2].get()
    )

    // can do this if the tasks are different types

    val res1 = threadPoolExecutor.submit(printStringTasks[0])
    val res2 = threadPoolExecutor.submit(printStringTasks[1])
    val res3 = threadPoolExecutor.submit(printStringTasks[2])

    val ts2 = ThreeStr(
            res1.get(),
            res2.get(),
            res3.get()
    )

    threadPoolExecutor.shutdown()

    print(ts1)
    print(ts2)
}

// prints:

// starting task: b
// starting task: a
// finished task: a
// starting task: c
// finished task: c
// finished task: b
// ThreeStr(a=a, b=b, c=c)