Hi,

PRs are welcome

Hi, thanks for your PR.
I like the idea of having a Bulkhead which queues permission requests when the concurrency limit is reached. It's somehow like the ThreadPoolBulkhead works. But the ThreadPoolBulkhead does not allow to execute a tasks in a different threadpool.

What we need is a NonBlockingBulkhead interface with CompletableFuture<Permission> tryAcquirePermission() . (The new non-blocking Bulkhead should be free of any Reactor classes.)

The non-blocking Bulkhead could be based on a semaphore and a non-blocking, thread-safe, circular fifo queue. Instead of using a time to live per permission request, we could use a circular array which queues N permission requests. We do have a good implementation of a circular fifo queue.

On every tryAcquirePermission() we return a CompletableFuture<Permission> and store the permission request in the circular queue. Then we pick the first permission request from the fifo queue and check if the Semaphore has a free permit.

• If yes, we drop the first permission request from the circular queue and execute future.complete(new Permission).
• If no, we drop the first permission request and execute future.completeExceptionally(new BulkheadFullException).

A permission request is queued, until

• the circular queue is full and the permission request ist dropped when a new permission request is stored
• or a former permission is released with permission.release().

When a permission is released, we pick the first permission request from the queue and allow the permission with future.complete(new Permission).

Since we have a circular queue, new permission requests will drop older permission requests automatically. We don't need any scheduler to remove tasks from the queue.