Qu'est-ce que les verrouillages optimistes et…

Les verrouillages optimistes et pessimistes sont des approches pour gérer l'accès parallèle aux données partagées dans des environnements concurrents (applications multithread, bases de données).

Verrouillage pessimiste :

Suppose que les conflits lors de l'accès aux données sont probables. Avant d'accéder à une ressource, le thread ou la transaction la verrouille (de manière exclusive ou partagée). D'autres threads tentant d'y accéder attendront que le verrou soit libéré.

Avantages : Garantit l'intégrité des données, simple à mettre en œuvre en cas de faible concurrence.
Inconvénients : Peut entraîner des blocages (attentes), réduire la capacité en cas de forte concurrence (deadlocks).
Exemples : le mot-clé synchronized en Java, verrouillages au niveau des lignes ou des tables dans les bases de données.

// Exemple de verrouillage pessimiste en Java
public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++; // Verrou sur l'objet, un seul thread peut exécuter cette méthode à la fois
    }

    public synchronized int getCount() {
        return count;
    }
}

Verrouillage optimiste :

Suppose que les conflits lors de l'accès aux données sont peu probables. L'accès aux données se fait sans verrouillage. Avant de sauvegarder, on vérifie que les données n'ont pas été modifiées par un autre thread depuis leur lecture. Si des modifications ont eu lieu, l'opération est annulée et généralement réessayée (retry).

Avantages : Haute capacité en cas de faible concurrence, pas de problèmes de deadlocks.
Inconvénients : Des conflits peuvent survenir, nécessitant des réessais, ce qui complique la logique. Non adapté pour des opérations longues ou à haute probabilité de conflits.
Exemples : opérations Compare-And-Swap (CAS), gestion de versions dans les bases de données (par exemple, utilisation de colonnes de version ou de timestamp).

// Exemple de verrouillage optimiste avec CAS (java.util.concurrent.atomic)
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        // Tentative d'incrément atomique
        // Si la valeur change entre la lecture et la mise à jour, la tentative est réessayée
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

Comparaison :

Caractéristique	Verrouillage pessimiste	Verrouillage optimiste
Supposition	Les conflits sont probables	Les conflits sont peu probables
Approche	Verrouillage jusqu'à l'accès	Accès sans verrouillage, vérification lors de l'écriture
En haute concurrence	Peut causer des blocages, réduire la capacité	Réinitialisations fréquentes, réduire la performance
En faible concurrence	Peut créer des surcharges	Haute capacité de traitement
Problème de deadlock	Possible	Impossible (du point de vue de l'accès concurrent aux ressources)

Qu'est-ce que les verrouillages optimistes et pessimistes?