Method deadlock_with

src/interest/concurrency/lock.rs:154–180

In parking_lot, the read lock is by default non-recursive if not specified. if two recursively acquired read locks in one thread are interleaved by a write lock from another thread, a deadlock may happen. The reason is write lock has higher priority than read lock in parking_lot. In std::sync, the implementation of read lock depends on the underlying OS. AFAIK, the implementation on Windows and Ma

(&self, other: &Self)

    /// spin explicitly documents no write priority. So the read lock in spin can
    /// be acquired recursively.
    pub fn deadlock_with(&self, other: &Self) -> DeadlockPossibility {
        use LockGuardTy::*;
        match (self, other) {
            (StdMutex(a), StdMutex(b))
            | (ParkingLotMutex(a), ParkingLotMutex(b))
            | (SpinMutex(a), SpinMutex(b))
            | (StdRwLockWrite(a), StdRwLockWrite(b))
            | (StdRwLockWrite(a), StdRwLockRead(b))
            | (StdRwLockRead(a), StdRwLockWrite(b))
            | (ParkingLotWrite(a), ParkingLotWrite(b))
            | (ParkingLotWrite(a), ParkingLotRead(b))
            | (ParkingLotRead(a), ParkingLotWrite(b))
            | (SpinWrite(a), SpinWrite(b))
            | (SpinWrite(a), SpinRead(b))
            | (SpinRead(a), SpinWrite(b))
                if a == b =>
            {
                DeadlockPossibility::Probably
            }
            (StdRwLockRead(a), StdRwLockRead(b)) | (ParkingLotRead(a), ParkingLotRead(b))
                if a == b =>
            {
                DeadlockPossibility::Possibly
            }
            _ => DeadlockPossibility::Unlikely,
        }
    }
}

/// The lockguard info. `span` is for report.