优先级最高的任务，为什么会被一个没抢它锁的任务拖住？

"""Deterministic single-CPU/single-lock model; no OS priority APIs or threads."""
import json


def simulate(medium_work=4, inherit=False, low_work=3):
    if type(medium_work) is not int or medium_work < 0 or type(low_work) is not int or low_work < 1:
        raise ValueError("invalid work units")
    base = {"L": 1, "M": 2, "H": 3}  # Larger means higher in this teaching model.
    remaining = {"L": low_work, "M": medium_work, "H": 1}
    owner = "L"  # L has acquired the only lock just before tick 0.
    blocked = False
    high_arrived = False
    waiting_since = None
    acquired_at = None
    high_finished = None
    timeline = []
    events = [{"at": 0, "event": "L already owns lock"}]
    tick = 0
    while any(remaining.values()):
        if tick == 1 and not high_arrived:
            high_arrived = True
            if owner is not None:
                blocked, waiting_since = True, tick
                events.append({"at": tick, "event": "H blocks on lock owned by L"})
        ready = []
        for name in ("L", "M", "H"):
            if remaining[name] <= 0 or (name in ("M", "H") and tick < 1):
                continue
            if name == "H" and blocked:
                continue
            priority = base[name]
            if inherit and name == owner and blocked:
                priority = base["H"]
            ready.append((priority, name))
        if not ready:
            raise AssertionError("unexpected deadlock in this single-lock workload")
        priority, running = max(ready)
        if running == "H" and owner is None:
            owner, acquired_at = "H", tick
            events.append({"at": tick, "event": "H acquires lock"})
        timeline.append({"tick": tick, "task": running, "effective_priority": priority})
        remaining[running] -= 1
        tick += 1
        if running == "L" and remaining["L"] == 0:
            owner, blocked = None, False
            events.append({"at": tick, "event": "L unlocks; L effective priority returns to 1"})
        if running == "H" and remaining["H"] == 0:
            owner, high_finished = None, tick
        if tick > low_work + medium_work + 5:
            raise AssertionError("model failed to finish")
    return {"inheritance": inherit, "timeline": timeline, "events": events,
            "H_finished_at": high_finished,
            "H_lock_wait_ticks": 0 if waiting_since is None else acquired_at - waiting_since,
            "total_ticks": tick}


def main():
    plain, inherited = simulate(), simulate(inherit=True)
    assert [x["task"] for x in plain["timeline"]] == list("LMMMMLLH")
    assert [x["task"] for x in inherited["timeline"]] == list("LLLHMMMM")
    assert (plain["H_finished_at"], inherited["H_finished_at"]) == (8, 4)
    assert (plain["H_lock_wait_ticks"], inherited["H_lock_wait_ticks"]) == (6, 2)
    checks = 4
    for low_work in range(2, 7):
        for medium_work in range(9):
            p = simulate(medium_work, False, low_work)
            i = simulate(medium_work, True, low_work)
            assert p["H_finished_at"] == low_work + medium_work + 1
            assert i["H_finished_at"] == low_work + 1
            assert p["total_ticks"] == i["total_ticks"] == low_work + medium_work + 1
            checks += 3
    # If L has already released the lock when H arrives, no lock wait occurs.
    for inherit in (False, True):
        no_wait = simulate(4, inherit, 1)
        assert no_wait["H_lock_wait_ticks"] == 0 and no_wait["H_finished_at"] == 2
        checks += 1
    try:
        simulate(-1)
        raise AssertionError("negative workload accepted")
    except ValueError:
        checks += 1
    print(json.dumps({"checks_passed": checks, "without_inheritance": plain,
                      "with_inheritance": inherited,
                      "boundary": "fixed virtual ticks; one CPU, one lock, no IO or lock chains"}, indent=2))


if __name__ == "__main__":
    main()