Why does my race condition demonstration in Python always yield the expected counter value?

The time between fetching the value of counter, incrementing it and reassigning it back is very short.

PYTHONCopied
counter = counter + 1

In order to force a race condition for demonstration purposes, you should extend that window perhaps with sleep

PYTHONCopied
tmp = counter
time.sleep(random.random())
counter = tmp + 1

I would also increase the number of concurrent tasks to give more chance for an issue to pop up.

This should dramatically illustrate things.

PYTHONCopied
import threading
import asyncio
import time
import random

def multithreading_race_condition():
    counter = 0
    iteration_count = 10
    task_count = 10

    def increment():
        nonlocal counter
        for _ in range(iteration_count):
            tmp = counter
            time.sleep(random.random())
            counter = tmp + 1

    threads = [threading.Thread(target=increment) for _ in range(task_count)]
    
    for t in threads:
        t.start()
    
    for t in threads:
        t.join()
    
    print(f"Multithreading Final Counter was {counter} expected {iteration_count * task_count}")

async def asyncio_race_condition():
    counter = 0
    iteration_count = 10
    task_count = 10

    async def increment():
        nonlocal counter
        for _ in range(iteration_count):
            tmp = counter
            await asyncio.sleep(random.random())
            counter = tmp + 1

    tasks = [asyncio.create_task(increment()) for _ in range(task_count)]
    
    await asyncio.gather(*tasks)
    
    print(f"Asyncio Final Counter was {counter} expected {iteration_count * task_count}")

def main():
    print("\nMultithreading Example:")
    multithreading_race_condition()

    print("\nAsyncio Example:")
    asyncio.run(asyncio_race_condition())

if __name__ == "__main__":
    main()

That should likely give you something like:

Multithreading Example:
Multithreading Final Counter was 10 expected 100

Asyncio Example:
Asyncio Final Counter was 10 expected 100

Dramatically illustrating a race condition.

Here is a second way to demonstrate a race using code a little more like what you have.

Note that if counter is loaded first you more likely will find a race and if loaded last you are likely not to find one. You can use dis to see how that might be true:

PYTHONCopied
import dis
test = """
counter = counter + 1 + (time.sleep(random.random()) or 0)
"""
print(dis.dis(test))

test2 = """
counter = 1 + (time.sleep(random.random()) or 0) + counter
"""
print(dis.dis(test2))

So, here are two examples that difffer only in the order of operations on either side of a long opperation. The first is very likely to demonstrate a race condition while the second is unlikely (though not impossible) to do so.

PYTHONCopied
import threading
import time
import random

def multithreading_race_condition():
    counter = 0

    def increment():
        nonlocal counter
        for _ in range(10):
            counter = counter + 1 + (time.sleep(random.random()) or 0)
            #counter = 1 + (time.sleep(random.random()) or 0) + counter

    threads = [threading.Thread(target=increment) for _ in range(10)]
    
    for t in threads:
        t.start()
    
    for t in threads:
        t.join()
    
    print(f"Multithreading Final Counter: {counter}")

def multithreading_no_race_condition():
    counter = 0

    def increment():
        nonlocal counter
        for _ in range(10):
            #counter = counter + 1 + (time.sleep(random.random()) or 0)
            counter = 1 + (time.sleep(random.random()) or 0) + counter

    threads = [threading.Thread(target=increment) for _ in range(10)]
    
    for t in threads:
        t.start()
    
    for t in threads:
        t.join()
    
    print(f"Multithreading Final Counter: {counter}")

def main():
    print("\nMultithreading Example with race:")
    multithreading_race_condition()

    print("\nMultithreading Example with (probably) no race:")
    multithreading_no_race_condition()

if __name__ == "__main__":
    main()

I am guessing that will give you:

Multithreading Example with race:
Multithreading Final Counter: 10

Multithreading Example with (probably) no race:
Multithreading Final Counter: 100