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

# coroutines

[christophsturm]

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

[Gerard Klijs]

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.

[christophsturm]

i want a generic pool not a thread pool.

[christophsturm]

usually i just use commons-pool but its time for a kotlin replacement, that does not block

[Gerard Klijs]

But what do you want to do?

[christophsturm]

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.

[christophsturm]

(as an example)

[christophsturm]

or a redis container can contain 16 databases so i can run 16 test that need it in parallel

[Scott Christopher]

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.

[christophsturm]

guys it has nothing to do with threads

[christophsturm]

its a pool for resources

[Scott Christopher]

I realise that

[christophsturm]

ok how would you do it with limited paralelism?

[christophsturm]

i was thinking just a suspend method getInstance that blocks until a docker container is free and then returns one

[christophsturm]

docker container is just an example of a heavy weight resource

[Scott Christopher]

Then a bounded Channel is probably good enough for that

[Scott Christopher]

You can read some of the examples in about limitedParallelism here: https://github.com/Kotlin/kotlinx.coroutines/issues/2919

[christophsturm]

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

[Scott Christopher]

https://kotlinlang.org/docs/channels.html#buffered-channels

[Scott Christopher]

You would need to have something wrapping it that returns them to the channel once they're released

[christophsturm]

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

[christophsturm]

but thanks for the inspiration

[Robert Jaros]

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

[christophsturm]

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

[christophsturm]

but good inspiration about the reactiveness

[christophsturm]

imo pooling is a different api than a channel but i can always use a channel in the implementation

[Scott Christopher]

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)
    }
  }
}

[Nick Allen]

That already exists. It's called Semaphore. See withPermit extension method.

[christophsturm]

That works for throttling but not pooling, right?