import kotlinx.coroutines.experimental.Deferred
import kotlinx.coroutines.experimental.async
import kotlinx.coroutines.experimental.delay
import java.util.*
import java.util.concurrent.ArrayBlockingQueue

fun main(args: Array<String>) {
    val defColl = (0..10000).map {
        async {
            delay(Random().nextInt(500))
            it
        }
    }
    val esh = ExecutorServiceHolder(defColl)

    esh.forEach {
        println(it)
    }
}

class ExecutorServiceHolder<T>(pool: Collection<Deferred<T>>, val waitTime: Long = 500) : Iterable<T> {
    private val pool = HashSet(pool)
    private val resultQueue = ArrayBlockingQueue<T>(pool.size)
    private val iterator = ExecutorIterator()

    override fun iterator(): Iterator<T> = iterator

    private inner class ExecutorIterator : Iterator<T> {
        override fun hasNext(): Boolean = resultQueue.isNotEmpty() || pool.isNotEmpty()

        override fun next(): T {
            extractResults()
            return resultQueue.poll()
        }

        private fun extractResults() {
            while (resultQueue.isEmpty()) {
                val completed = pool.filter {
                    it.isCompleted
                }

                pool.removeAll(completed)

                completed.forEach {
                    resultQueue.add(it.getCompleted())
                }
                if (resultQueue.isEmpty()) {
                    Thread.sleep(waitTime)
                }
            }
        }
    }
}