In your case you could at least very easily launch the comparison of the image with each other image in a separate coroutine. Then, if you only have very few images to compare (less than the number of threads), you could also make a single comparison parallel if the image itself is big enough for it to be useful.

So in your case this means you could have one coroutine send all the images to compare to a channel, and N coroutines reading elements from this channel and performing the distance operation, and maybe sending the "measured images" to a second channel so the initial sender can combine the results.

The initial approach I had in mind was the following. Assuming you have this function:

fun distance(img1: Image, img2: Image): Long = TODO()

You could write this:

// returns null if the list is empty, you could also throw an exception instead
suspend fun findClosestImageOrNull(src: Image, candidates: List<Image>): Image? {

    // you can also define this helper class outside the function if needed elsewhere
    data class MeasuredCandidate(val img: Image, val distance: Long)

    val measuredCandidates = coroutineScope {
        candidates
            .map { candidate ->
                async { MeasuredCandidate(candidate, distance(src, candidate)) }
            }
            .awaitAll()
    }
    return measuredCandidates.minByOrNull { it.distance }?.img
}

This defines the computation in a concurrent way. If you want to run this in parallel, simply run

findClosestImageOrNull

in a multi-threaded dispatcher such as `Dispatchers.Default`:

suspend fun main() {
    withContext(Dispatchers.Default) {
        findClosestImageOrNull(...)
    }
}

You could also replace

coroutineScope

with

withContext(Dispatchers.Default)

right inside

findClosestImageOrNull

, but this prevents the caller from choosing another dispatcher (e.g. in tests). That said, because the

distance

function is not suspending, the coroutines will be run sequentially if you run this function on a single-threaded dispatcher, so choosing a good dispatcher inside the function might avoid mistakes on the calling side. Up to you!