Comment les verrous pessimistes et optimistes dans les fonctions Java assurent-ils la sécurité des threads ?

Deux façons d'assurer la sécurité des threads dans les fonctions Java : verrouillage pessimiste : acquérir le verrou avant d'accéder aux données pour empêcher l'accès simultané par d'autres threads afin de garantir la cohérence des données. (mot-clé synchronisé) Verrouillage optimiste : vérifiez les données à la fin de la transaction et annulez la transaction si les données sont modifiées pour améliorer la concurrence. (Classe atomique dans le package java.util.concurrent.atomic)

Comment assurer la sécurité des threads entre les verrous pessimistes et les verrous optimistes dans les fonctions Java ?

La sécurité des threads est cruciale pour les environnements multithread, garantissant l'intégrité et la cohérence des données lorsque les données sont accessibles simultanément. En Java, le verrouillage pessimiste et le verrouillage optimiste sont les deux principaux mécanismes permettant d'assurer la sécurité des threads. Ci-dessous, nous explorerons comment ils sont mis en œuvre et fournirons des exemples pratiques.

Verrouillage pessimiste

Le verrouillage pessimiste est basé sur l'hypothèse que les données peuvent être modifiées par d'autres threads à tout moment. Par conséquent, il acquiert le verrou dès qu'il accède aux données, empêchant ainsi les autres threads d'accéder aux données jusqu'à ce que le verrou soit libéré. L’avantage du verrouillage pessimiste est qu’il peut garantir la cohérence des données, mais l’inconvénient est qu’il peut conduire à une concurrence de verrouillage et à une impasse.

Le mot-clé synchronized est une méthode courante pour implémenter le verrouillage pessimiste en Java. Il marque un bloc de code comme section critique et seul le thread qui acquiert le verrou peut entrer dans le bloc de code. synchronized 关键字是 Java 中实现悲观锁的常用方法。它将代码块标记为临界区，只有获取锁的线程才能进入该代码块。

public class Counter {

    private int count;

    public synchronized void increment() {
        count++;
    }

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

乐观锁

乐观锁基于这样的假设：当线程访问数据时，数据不太可能被其他线程修改。它在事务结束时才对数据进行验证，如果数据被修改，则回滚事务。乐观锁的优点是能提高并发性，缺点是如果数据被修改，可能会导致事务失败。

在 Java 中，java.util.concurrent.atomic 包中的原子类可以实现乐观锁。原子类中的操作是原子性的，保证了并发访问数据的正确性。

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {

    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

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

实战案例：多线程银行账户

为了演示悲观锁和乐观锁在实际场景中的应用，我们考虑一个多线程银行账户。

• 悲观锁实现：

public class BankAccount {

    private int balance;

    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }

    public synchronized int getBalance() {
        return balance;
    }
}

• 乐观锁实现：

import java.util.concurrent.atomic.AtomicInteger;

public class BankAccount {

    private AtomicInteger balance = new AtomicInteger(0);

    public void withdraw(int amount) {
        while (true) {
            int currentBalance = balance.get();
            if (currentBalance >= amount) {
                if (balance.compareAndSet(currentBalance, currentBalance - amount)) {
                    break;
                }
            } else {
                break;
            }
        }
    }

    public int getBalance() {
        return balance.get();
    }
}

使用 optimistic 锁，在取款时，它会获得当前余额，然后尝试使用 compareAndSetrrreee

Verrouillage optimiste

Le verrouillage optimiste est basé sur l'hypothèse que lorsqu'un thread accède aux données, il est peu probable que les données soient modifiées par d'autres threads. Il valide uniquement les données à la fin de la transaction et annule la transaction si les données ont été modifiées. L'avantage du verrouillage optimiste est qu'il peut améliorer la concurrence, mais l'inconvénient est que si les données sont modifiées, la transaction peut échouer.

En Java, la classe atomique du package java.util.concurrent.atomic peut implémenter le verrouillage optimiste. Les opérations de la classe atomique sont atomiques, garantissant l'exactitude de l'accès simultané aux données. 🎜rrreee🎜🎜Cas pratique : compte bancaire multithread🎜🎜🎜Pour démontrer l'application du verrouillage pessimiste et du verrouillage optimiste dans des scénarios pratiques, nous considérons un compte bancaire multithread. 🎜

• 🎜Mise en œuvre du verrouillage pessimiste : 🎜

rrreee

• 🎜Mise en œuvre du verrouillage optimiste : 🎜

rrreee🎜Utiliser le verrouillage optimiste, lors du retrait , il obtient le solde actuel puis tente de soustraire atomiquement le montant du retrait à l'aide de compareAndSet. Si le solde est insuffisant, l'opération échouera et le thread réessayera. 🎜🎜🎜Choisissez le verrouillage pessimiste ou le verrouillage optimiste🎜🎜🎜Le choix du verrouillage pessimiste ou du verrouillage optimiste dépend du scénario spécifique. S'il existe peu d'accès simultanés aux données ou si la cohérence des données est essentielle, le verrouillage pessimiste est plus approprié. Si les accès simultanés aux données sont fréquents et que la cohérence des données permet un certain degré de compromis, le verrouillage optimiste est plus approprié. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!