Struct RawDetachingRwLock 

pub struct RawDetachingRwLock(/* private fields */);

A reader-writer lock whose blocking acquires detach first, and which is the raw lock it wraps in every other respect.

Use through PyDetachingRwLock.

Why this exists

Stopping the world means waiting until every other thread sits at SUSPENDED, and there are two ways a thread gets there:

• A DETACHED thread is not running interpreter code, so the requester moves it to SUSPENDED itself. The thread never finds out.
• An ATTACHED thread can only suspend itself, at a safepoint — the check check_signals makes between bytecodes.

A thread blocked acquiring a lock runs no bytecode, so it reaches no safepoint. While ATTACHED it is a thread the world cannot stop for as long as it waits, and the requester waits without a bound.

On its own that is a pause. It becomes a deadlock as soon as the lock being waited for is held by a thread the same stop has already parked:

A  holds the lock, blocks inside allow_threads  -> DETACHED
B  requests a stop, and parks A                 -> A is SUSPENDED, holding the lock
C  wants the same lock, and waits for it        -> ATTACHED, blocked

  B waits for C to suspend           C reaches no safepoint
  C waits for A to release           A is parked
  A waits for B to start the world   B is still waiting for C

No thread in that cycle can break it, because none of them is running. It is not hypothetical: an SSLSocket.read against a peer that completed a handshake and then went quiet froze whole processes this way, the main thread included, so not even a Python-level timeout could fire.

The holder cannot be the one to give way. A lock is held across a blocking call precisely because that is what the call needs. So the waiter gives way instead: it leaves its interpreter for the duration of the wait, which is what a blocking call does anyway, and a waiter that has left is a waiter the requester can park. C detaches before it blocks, the stop completes, B finishes, A resumes and releases, and C takes the lock and attaches again.

Only for locks a stop-the-world section never takes

The wait acquires the lock while detached, so the thread comes back holding it, and re-attaching is a point at which a stop-the-world in flight will park the thread. It is therefore parked holding the lock. Everything that stops the world must be able to finish without that lock: if a collection were to take it, the collection would block on a thread only the collection can release, and neither would move again.

So this is opt-in per lock, and the rule for opting in is that nothing reachable from a stop-the-world section takes the same lock. An object whose payload holds no references — nothing for the collector to traverse into — satisfies that; most do not.

Not implementing the vm’s Traverse for this lock enforces part of that: a payload holding one cannot derive Traverse, so it cannot become something a collection walks into. Only that part. A collection is not the only thing that stops the world — dumping tracebacks, enumerating thread frames and forking all do — and nothing checks what those reach. For them the rule is still a convention.

Trait Implementations

impl RawRwLock for RawDetachingRwLock

const INIT: Self

Initial value for an unlocked RwLock.

type GuardMarker = <RawCellRwLock as RawRwLock>::GuardMarker

Marker type which determines whether a lock guard should be Send. Use one of the GuardSend or GuardNoSend helper types here.

fn lock_shared(&self)

Acquires a shared lock, blocking the current thread until it is able to do so.

fn try_lock_shared(&self) -> bool

Attempts to acquire a shared lock without blocking.

unsafe fn unlock_shared(&self)

Releases a shared lock.

fn lock_exclusive(&self)

Acquires an exclusive lock, blocking the current thread until it is able to do so.

fn try_lock_exclusive(&self) -> bool

Attempts to acquire an exclusive lock without blocking.

unsafe fn unlock_exclusive(&self)

Releases an exclusive lock.

fn is_locked(&self) -> bool

Checks if this RwLock is currently locked in any way.

fn is_locked_exclusive(&self) -> bool

Check if this RwLock is currently exclusively locked.

impl RawRwLockDowngrade for RawDetachingRwLock

unsafe fn downgrade(&self)

Atomically downgrades an exclusive lock into a shared lock without allowing any thread to take an exclusive lock in the meantime.

impl RawRwLockUpgrade for RawDetachingRwLock

fn lock_upgradable(&self)

Acquires an upgradable lock, blocking the current thread until it is able to do so.

fn try_lock_upgradable(&self) -> bool

Attempts to acquire an upgradable lock without blocking.

unsafe fn unlock_upgradable(&self)

Releases an upgradable lock.

unsafe fn upgrade(&self)

Upgrades an upgradable lock to an exclusive lock.

unsafe fn try_upgrade(&self) -> bool

Attempts to upgrade an upgradable lock to an exclusive lock without blocking.

impl RawRwLockUpgradeDowngrade for RawDetachingRwLock

unsafe fn downgrade_upgradable(&self)

Downgrades an upgradable lock to a shared lock.

unsafe fn downgrade_to_upgradable(&self)

Downgrades an exclusive lock to an upgradable lock.