Threads, locks and the GIL

import threading
from collections.abc import Callable


def run_all(jobs: list[Callable[[], str]]) -> list[str]:
    """Run each job in its own thread; return the results in the order of jobs."""
    # This runs the jobs one after another in the main thread.
    # Start one threading.Thread per job, then join them all.
    return [job() for job in jobs]


if __name__ == "__main__":
    print(run_all([lambda: "one", lambda: "two", lambda: threading.current_thread().name]))

import threading

from main import run_all


def test_order():
    """The results come back in the order of the jobs"""
    got = run_all([lambda: "a", lambda: "b", lambda: "c"])
    assert got == ["a", "b", "c"], f"run_all returned {got!r}, expected ['a', 'b', 'c']"


def test_not_in_main_thread():
    """Every job runs outside the main thread"""
    got = run_all([lambda: threading.current_thread().name for _ in range(3)])
    assert "MainThread" not in got, f"the jobs ran in {got!r}: start a Thread for each job"


def test_all_at_once():
    """All three jobs run at the same time and meet at a barrier"""
    barrier = threading.Barrier(3, timeout=0.5)

    def job():
        barrier.wait()
        return "met"

    try:
        got = run_all([job, job, job])
    except threading.BrokenBarrierError:
        got = []
    assert got == ["met", "met", "met"], f"run_all returned {got!r}: start every thread before you join any"

import threading
from collections.abc import Callable


class Account:
    def __init__(self) -> None:
        self.balance = 0
        self._lock = threading.Lock()

    def deposit(self, amount: int, pause: Callable[[], None] = lambda: None) -> None:
        """Add amount to the balance. pause() runs between the read and the write."""
        # Two threads can both read the old balance here. Use self._lock.
        seen = self.balance
        pause()
        self.balance = seen + amount


if __name__ == "__main__":
    account = Account()
    threads = [threading.Thread(target=account.deposit, args=(10,)) for _ in range(2)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    print("balance:", account.balance)

import threading

from main import Account


def deposit_together(account, amount, pause):
    threads = [threading.Thread(target=account.deposit, args=(amount, pause)) for _ in range(2)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    return account.balance


def test_one_deposit():
    """One deposit of 25 gives a balance of 25"""
    account = Account()
    account.deposit(25)
    assert account.balance == 25, f"the balance is {account.balance}, expected 25"


def test_no_lost_update():
    """Two deposits of 10 at the same moment give 20"""
    barrier = threading.Barrier(2, timeout=0.05)

    def pause():
        try:
            barrier.wait()  # both threads stop here, between read and write
        except threading.BrokenBarrierError:
            pass

    got = deposit_together(Account(), 10, pause)
    assert got == 20, f"the balance is {got}, expected 20: one deposit was lost, so hold the lock from the read to the write"


def test_lock_is_free_afterwards():
    """The lock is released after each deposit"""
    account = Account()
    account.deposit(5)
    account.deposit(5)
    assert not account._lock.locked(), "the lock is still held after deposit(): use with self._lock:"
    assert account.balance == 10, f"the balance is {account.balance}, expected 10"