parking_lot pour Rust : primitives de synchronisation rapides

La bibliothèque parking_lot est l'une des implémentations les plus populaires et performantes des primitives de synchronisation pour le langage Rust. Elle offre une alternative aux mutex standards (std::sync::Mutex), aux verrous de lecture-écriture (std::sync::RwLock) et aux variables conditionnelles (std::sync::Condvar), avec des performances nettement supérieures et une empreinte mémoire réduite.

Pourquoi utiliser cette bibliothèque ? Les primitives de synchronisation standard de Rust, bien que sûres, présentent plusieurs inconvénients : elles utilisent des appels système (futex sous Linux) même dans des scénarios simples, nécessitent de la mémoire supplémentaire pour les flags et ont une implémentation interne plus complexe. parking_lot résout ces problèmes en utilisant des algorithmes plus efficaces (comme les verrous optimistes et les boucles d'attente actives) et en minimisant les frais généraux. Le résultat : un code plus rapide, en particulier dans les applications multithreadées à forte contention.

La bibliothèque est entièrement compatible avec Rust et ne nécessite aucun code unsafe de la part de l'utilisateur. Elle propose les mêmes interfaces que la bibliothèque standard, mais avec des fonctionnalités supplémentaires : Mutex avec support des timeouts, RwLock avec file d'attente équitable, Once pour l'initialisation paresseuse et ReentrantMutex pour les verrous réentrants. parking_lot est la référence de facto pour les applications Rust hautes performances, des serveurs web aux moteurs de jeux.

Installation

Ajoutez la bibliothèque dans le fichier Cargo.toml de votre projet :

[dependencies]
parking_lot = "0.12"

Exécutez ensuite la commande :

cargo build

Ou, si vous utilisez cargo add (depuis Rust 1.62) :

cargo add parking_lot

Vous pouvez alors importer les primitives depuis la bibliothèque :

use parking_lot::{Mutex, RwLock, Condvar, Once, ReentrantMutex};

Démarrage rapide : exemple minimal fonctionnel

Voici un exemple simple d'utilisation de Mutex de parking_lot pour protéger un compteur partagé dans un environnement multithreadé :

use parking_lot::Mutex;
use std::thread;

fn main() {
    // Création d'un mutex encapsulant une valeur
    let counter = Mutex::new(0);

    // Création de 10 threads, chacun incrémente le compteur de 1
    let mut handles = vec![];
    for _ in 0..10 {
        let handle = thread::spawn(|| {
            // Acquisition du verrou — .lock() retourne un garde RAII
            let mut guard = counter.lock();
            *guard += 1;
            // Le garde est automatiquement libéré à la sortie de la portée
        });
        handles.push(handle);
    }

    // Attente de la fin de tous les threads
    for handle in handles {
        handle.join().unwrap();
    }

    // Lecture de la valeur finale
    let final_value = *counter.lock();
    println!("Valeur finale : {}", final_value); // Devrait être 10
}

Dans cet exemple, counter.lock() retourne un MutexGuard qui libère automatiquement le verrou lors de sa destruction. Contrairement au std::sync::Mutex standard, il n'est pas nécessaire de gérer les erreurs (poisoning) — parking_lot n'empoisonne pas le mutex par défaut en cas de panique.

Méthodes et types principaux

Voici 8 méthodes/types clés de la bibliothèque parking_lot avec leurs signatures, descriptions et exemples.

1. Mutex::lock()

Signature : pub fn lock(&self) -> MutexGuard<'_, T>

Description : Acquiert le mutex, bloquant le thread courant jusqu'à l'obtention du verrou. Retourne un garde RAII qui libère automatiquement le verrou à la sortie de la portée.

use pa