Concurrency in Python: Solving the Dining Philosophers Problem

Tabrez Ahmed — Sun, 19 Apr 2026 17:26:11 +0000

If you are writing multithreaded applications, you are going to run into deadlocks. There’s no avoiding it. To understand how to fix them, you need to understand the Dining Philosophers problem.

Five philosophers sit at a round table. There are five forks. To eat, a philosopher needs the fork on their left and the fork on their right. If everyone grabs their left fork at the exact same time, they all wait forever for the right fork. Deadlock.

In this series, my team and I will break down how we built a visual simulator for this problem in Python. For part one, we are looking at the core mechanics and Dijkstra’s Resource Hierarchy solution.
The Setup

We want raw execution without third-party bloat, so we rely entirely on Python's standard threading library. Each philosopher is a daemon thread, and each fork is a threading.Lock.
Python

import threading

NUM_PHILOSOPHERS = 5
forks = [threading.Lock() for _ in range(NUM_PHILOSOPHERS)]

If we just wrote forks[left].acquire() followed by forks[right].acquire(), the script would eventually freeze.
The Solution: Resource Hierarchy

To break the circular wait, we assign a hierarchy to the resources (forks). Instead of "grab left, then right," the rule becomes "grab the lower-numbered fork first, then the higher-numbered one."

Here is how that logic looks in our simulation loop:
Python

def _cycle_resource_hierarchy(self, idx: int):
    # Determine fork indices
    left  = (idx - 1) % NUM_PHILOSOPHERS
    right = idx

    # Establish hierarchy
    lo, hi = min(left, right), max(left, right)

    # Acquire in strict order
    self.forks[lo].acquire()
    self.forks[hi].acquire()

    # CRITICAL SECTION: Eating
    time.sleep(random.uniform(0.4, 1.5))

    # Release locks
    self.forks[hi].release()
    self.forks[lo].release()

Because the last philosopher (index 4) sits next to the first fork (index 0), they will try to grab fork 0 first, while philosopher 0 is also trying to grab fork 0 first. The cycle is broken. Someone gets blocked, allowing someone else to eat.

My First Week Learning Offensive Security (Before Hitting the Paywall)

Tabrez Ahmed — Sun, 05 Apr 2026 12:06:17 +0000

I started learning red team fundamentals on TryHackMe. Here's what I learned before running into premium content limitations.

Day 1: Red Team Basics

What offensive security actually means
Learned about dirb tool for directory brute-forcing
[Explain what dirb does and why it's useful]

Day 2: Blue Team Perspective

Defense in depth concept
SOC analyst role
What SIEM tools do

Day 3: Research Skills

How to find CVEs and exploits
Tools: Shodan, Censys, VirusTotal
GitHub for exploit code

Day 4: Linux Fundamentals

Commands I learned: ls, cd, cat, grep
Operators: &&, >, |

The Paywall Problem

TryHackMe's free tier is limited. Switching to OverTheWire (completely free) to continue learning.

Next Week

Starting OverTheWire Bandit challenges. Goal: Complete levels 0-10.

DEV Community: Tabrez Ahmed