parking_lot

Using parking_lot in production has been remarkably smooth. The API is intentionally designed as a near drop-in replacement for std::sync primitives - you literally just swap `std::sync::Mutex` for `parking_lot::Mutex` and it works. The learning curve is essentially zero if you already know Rust's standard library. The main difference to learn is that lock() doesn't return a Result (it can't be poisoned), which actually simplifies error handling in most cases.

The documentation is minimal but effective since it mostly references std docs and highlights the differences. What impressed me most is how straightforward debugging remains - the primitives behave predictably and don't introduce mysterious behavior. When I've had deadlocks or contention issues, standard Rust debugging tools work perfectly. Error messages are clear because you're still working with familiar Rust patterns.

Community support isn't extensive simply because there's rarely much to ask - it just works. GitHub issues get addressed, but most questions are answered by "it works like std but faster." Common use cases like protecting shared state or building concurrent data structures are identical to std, just more efficient.

In production systems handling high contention workloads, parking_lot delivers on its core promise: smaller memory footprint and better performance than standard library mutexes. The API is intentionally nearly identical to std::sync, making migration trivial—literally search-replace Mutex imports in most cases. We've measured 15-20% latency improvements in hot paths under load, with lock sizes dropping from 40 to 1 byte for uncontended cases.

The library shines in observability and operational control. RwLock upgradable reads are a game-changer for cache implementations, avoiding the unlock-relock dance that causes race windows. Deadlock detection in debug builds has caught issues during development that would've been nightmares in production. The const constructors eliminate lazy_static boilerplate for global locks, reducing initialization overhead.

One gotcha: parking_lot locks are NOT poisoned on panic like std locks, which changes error handling semantics. This is actually preferable for most production systems (panics shouldn't spread corruption assumptions), but requires awareness during migration. Timeout behavior is consistent and predictable, and the lack of configuration knobs is actually a feature—less to tune means fewer production surprises.

In production workloads with high lock contention, parking_lot consistently outperforms std::sync primitives. The Mutex and RwLock implementations are genuinely faster and smaller - we measured 30-40% reduction in lock acquisition latency under moderate contention. The API is intentionally a near drop-in replacement for std types, so migration is typically just changing use statements. No configuration needed, it just works better out of the box.

The lack of poisoning on panic is actually a huge operational win. Standard library locks poison on panic, forcing you to deal with PoisonError everywhere. Parking_lot removes this - if a thread panics while holding a lock, the lock is simply released. This matches behavior of locks in most other languages and eliminates boilerplate error handling that rarely adds value in practice.

Resource management is excellent - locks are small (1 byte for Mutex vs std's larger size) and the global parker thread pool is efficiently managed. The fairness guarantees prevent starvation better than std locks. One gotcha: ReentrantMutex exists but isn't a direct std replacement since std doesn't have one - useful for specific patterns but needs careful consideration.