Threads, Locks und der 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():
    """Die Ergebnisse kommen in der Reihenfolge der Jobs zurück"""
    got = run_all([lambda: "a", lambda: "b", lambda: "c"])
    assert got == ["a", "b", "c"], f"run_all lieferte {got!r}, erwartet war ['a', 'b', 'c']"


def test_not_in_main_thread():
    """Jeder Job läuft außerhalb des Haupt-Threads"""
    got = run_all([lambda: threading.current_thread().name for _ in range(3)])
    assert "MainThread" not in got, f"die Jobs liefen in {got!r}: starten Sie für jeden Job einen Thread"


def test_all_at_once():
    """Alle drei Jobs laufen gleichzeitig und treffen sich an einer 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 lieferte {got!r}: starten Sie alle Threads, bevor Sie einen joinen"

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():
    """Eine Einzahlung von 25 ergibt einen Stand von 25"""
    account = Account()
    account.deposit(25)
    assert account.balance == 25, f"der Stand ist {account.balance}, erwartet war 25"


def test_no_lost_update():
    """Zwei gleichzeitige Einzahlungen von 10 ergeben 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"der Stand ist {got}, erwartet war 20: eine Einzahlung ging verloren, halten Sie den Lock vom Lesen bis zum Schreiben"


def test_lock_is_free_afterwards():
    """Der Lock ist nach jeder Einzahlung wieder frei"""
    account = Account()
    account.deposit(5)
    account.deposit(5)
    assert not account._lock.locked(), "der Lock ist nach deposit() noch belegt: nutzen Sie with self._lock:"
    assert account.balance == 10, f"der Stand ist {account.balance}, erwartet war 10"