is there a kotlin pool library like commons-pool, maybe one that uses coroutines?

Not sure what you are looking for, you can a Thead pool into a coroutine ditpatcher like https://github.com/gklijs/kotlin-coroutines-demo/blob/fd90929e310e1d20c95c3a6ec8836500eb605274/src/main/kotlin/tech/gklijs/Util.kt#L76.

i want a generic pool not a thread pool.

But what do you want to do?

main use is for throttling, i have a test runner that runs tests in parallel. but i don’t want to spin up more than 10 docker containers.

If you can wait until 1.6.0, the new

CoroutineDispatcher.limitedParallelism

would be useful. In the interim, I make use of a bounded Channel for a similar use case.

guys it has nothing to do with threads

I realise that

ok how would you do it with limited paralelism?

Then a bounded Channel is probably good enough for that

how would i reuse resources that become free with a bounded channel?

i have used channels for throttling before. just not sure if its also optimal for pooling

Perhaps look for something reactive (e.g. https://github.com/reactor/reactor-pool) and use coroutines-reactor.

thanks will look at that too. but i guess a pool is really something very simple so no need for any dependencies

Yeah, I was just thinking something simple along the lines of this, though obviously tweaked depending on what features of the pool you need

class Pool<A> private constructor(private val channel: Channel<A>) {

  suspend fun borrow(fn: suspend (A) -> Unit) {
    val item = channel.receive()
    fn(item)
    channel.send(item)
  }

  companion object {
    suspend fun <A> create(size: Int, factory: suspend () -> A): Pool<A> {
      val channel = Channel<A>(size)
      repeat(size) {
        channel.send(factory())
      }
      return Pool(channel)
    }
  }
}

That already exists. It's called Semaphore. See

withPermit

extension method.

That works for throttling but not pooling, right?