Limit number of futures running in parallel (now updated with seize/release implementations suggested by roland)

ThrottledExecutionContext.scala

import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.atomic.AtomicInteger
import scala.concurrent.ExecutionContext
import scala.util.control.NonFatal
import scala.annotation.tailrec

//inspired by https://gist.github.com/viktorklang/4552423

object ThrottledExecutionContext {
  def apply(maxConcurrents: Int)(implicit context: ExecutionContext): ExecutionContext = {

    require(maxConcurrents > 0, s"ThrottledExecutionContext.maxConcurrents must be greater than 0 but was $maxConcurrents")

    new ConcurrentLinkedQueue[Runnable] with Runnable with ExecutionContext {
      private final val on = new AtomicInteger(0)

      @tailrec private def seizeSlot(): Boolean = {
        val n = on.get
        n < maxConcurrents && (on.compareAndSet(n, n+1) || seizeSlot())
      }
      
      private def releaseSlot(): Unit = on.decrementAndGet()

      override def add(task: Runnable): Boolean = {
        val r = super.add(task)
        attach()
        r
      }

      final def run(): Unit = try {
        poll() match {
          case null => ()
          case some => try some.run() catch { case NonFatal(t) => context reportFailure t }
        }
      } finally {
        releaseSlot()
        attach()
      }

      final def attach(): Unit =
        if(!isEmpty && seizeSlot()) {
          try context.execute(this) catch { case t: Throwable => releaseSlot(); throw t }
        }

      override final def execute(task: Runnable): Unit = add(task)
      override final def reportFailure(t: Throwable): Unit = context reportFailure t
    }
  }
}

Looks interesting for carving out sub-contexts; your seizeSlot and releaseSlot are broken, though, because the CAS failing does not mean that n was increased (as you seem to assume). Why not

@tailrec private def seizeSlot(): Boolean = {
  val n = on.get
  n < max && (on.compareAndSet(n, n+1) || seizeSlot())
}
@tailrec private def releaseSlot(): Unit = on.decrementAndGet()

@tailrec doesn't make sense on releaseSlot there, but it's definitely cleaner than my implementation. Pushing it through the unit tests now :)