Implement Bulkhead Thread Pool Isolation in Python

import threading
import time
import random
from concurrent.futures import ThreadPoolExecutor


class Bulkhead:
    """Simple bulkhead isolation: separate thread pools for different tasks."""

    def __init__(self, max_workers):
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        self.active = 0
        self.lock = threading.Lock()

    def submit(self, fn, *args, **kwargs):
        with self.lock:
            if self.active >= self.executor._max_workers:
                raise RuntimeError("Bulkhead full — task rejected")
            self.active += 1

        def wrapped():
            try:
                return fn(*args, **kwargs)
            finally:
                with self.lock:
                    self.active -= 1

        return self.executor.submit(wrapped)


def slow_task(name, delay):
    time.sleep(delay)
    return f"{name} done in {delay:.1f}s"


def fast_task(name):
    return f"{name} immediate"


if __name__ == "__main__":
    # Two isolated bulkheads: one for slow DB work, one for quick caching
    db_bulkhead = Bulkhead(max_workers=2)
    cache_bulkhead = Bulkhead(max_workers=3)

    # Saturate the DB bulkhead
    db_futures = [db_bulkhead.submit(slow_task, f"db-{i}", random.uniform(0.2, 0.5))
                  for i in range(2)]

    # Cache bulkhead is independent — keeps working while DB is full
    cache_results = [cache_bulkhead.submit(fast_task, f"cache-{i}") for i in range(3)]
    print("Cache results:", [f.result() for f in cache_results])

    # Third DB task should fail — pool is exhausted
    try:
        db_bulkhead.submit(slow_task, "db-overload", 0.1)
        print("Unexpected success — bulkhead should have rejected")
    except RuntimeError as e:
        print(f"Rejected as expected: {e}")

    for f in db_futures:
        print(f.result())