SimPy Deadlock Explained: Why Your Simulation Hangs

import simpy

def process_a(env, resource_1, resource_2):
    with resource_1.request() as req1:
        yield req1
        print(f"{env.now}: A has resource 1")
        yield env.timeout(1)

        with resource_2.request() as req2:
            yield req2  # STUCK - B has resource 2
            print(f"{env.now}: A has both resources")

def process_b(env, resource_1, resource_2):
    with resource_2.request() as req2:
        yield req2
        print(f"{env.now}: B has resource 2")
        yield env.timeout(1)

        with resource_1.request() as req1:
            yield req1  # STUCK - A has resource 1
            print(f"{env.now}: B has both resources")

env = simpy.Environment()
r1 = simpy.Resource(env, capacity=1)
r2 = simpy.Resource(env, capacity=1)

env.process(process_a(env, r1, r2))
env.process(process_b(env, r1, r2))
env.run()  # Hangs forever

def process_a(env, resource_1, resource_2):
    # Always get resource 1 first, then resource 2
    with resource_1.request() as req1:
        yield req1
        with resource_2.request() as req2:
            yield req2
            yield env.timeout(5)

def process_b(env, resource_1, resource_2):
    # Same order: resource 1 first, then resource 2
    with resource_1.request() as req1:
        yield req1
        with resource_2.request() as req2:
            yield req2
            yield env.timeout(5)

def process_with_timeout(env, resource_1, resource_2):
    with resource_1.request() as req1:
        yield req1

        req2 = resource_2.request()
        result = yield req2 | env.timeout(10)

        if req2 in result:
            # Got the resource
            yield env.timeout(5)
            resource_2.release(req2)
        else:
            # Timed out - release first resource and retry later
            print(f"{env.now}: Couldn't get resource 2, backing off")
            req2.cancel()
            yield env.timeout(1)  # Back off
            # Retry logic here

def all_or_none(env, resources):
    """Request all resources or none."""
    requests = [r.request() for r in resources]

    # Wait for all
    results = yield simpy.AllOf(env, requests)

    try:
        yield env.timeout(5)  # Do work
    finally:
        for req, resource in zip(requests, resources):
            resource.release(req)

class ResourceManager:
    def __init__(self, env, resources):
        self.env = env
        self.resources = resources
        self.lock = simpy.Resource(env, capacity=1)

    def acquire_all(self, resource_names):
        """Acquire multiple resources atomically."""
        with self.lock.request() as lock_req:
            yield lock_req

            requests = []
            for name in resource_names:
                req = self.resources[name].request()
                yield req
                requests.append((name, req))

            return requests

    def release_all(self, requests):
        """Release multiple resources."""
        for name, req in requests:
            self.resources[name].release(req)

def deadlock_detector(env, processes, timeout=100):
    """Detect if simulation makes no progress."""
    last_time = env.now

    while True:
        yield env.timeout(timeout)

        if env.now == last_time:
            print(f"WARNING: No progress in {timeout} time units")
            print("Possible deadlock detected")

            # Log resource states
            for name, resource in resources.items():
                print(f"  {name}: {resource.count}/{resource.capacity} busy, "
                      f"{len(resource.queue)} waiting")

        last_time = env.now

def philosopher(env, left_fork, right_fork, name):
    while True:
        # Think
        yield env.timeout(random.expovariate(1))

        # Try to eat (potential deadlock!)
        with left_fork.request() as left:
            yield left
            # All philosophers grab left fork...

            with right_fork.request() as right:
                yield right  # ...then wait for right fork
                yield env.timeout(random.expovariate(1))

def producer(env, buffer, producer_lock):
    with producer_lock.request() as req:
        yield req
        # Wait for buffer space - but consumer needs producer_lock!
        yield buffer.put(item)

def consumer(env, buffer, producer_lock):
    with producer_lock.request() as req:
        yield req
        # Deadlock if buffer empty and producer waiting
        item = yield buffer.get()

import signal
import sys

def timeout_handler(signum, frame):
    print("Simulation appears deadlocked!")
    print(f"Current time: {env.now}")

    # Print all pending events
    for event in env._queue[:10]:
        print(f"  Pending: {event}")

    sys.exit(1)

# Set timeout
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(60)  # 60 second timeout

env.run()
signal.alarm(0)  # Cancel alarm