Implémentation et application du mécanisme de verrouillage dans la programmation parallèle Java

Dans la programmation parallèle Java, le mécanisme de verrouillage est un outil important pour contrôler l'accès aux ressources partagées, notamment les verrous intégrés, les verrous explicites et les verrous en lecture-écriture. Ils sont utilisés pour protéger les données partagées, contrôler l’ordre d’accès et attendre la fin des tâches du thread. Dans un cas pratique, un verrou intégré est utilisé pour protéger l'accès aux soldes des comptes bancaires afin de garantir que l'accès simultané est sûr et correct.

Mécanisme de verrouillage dans la programmation parallèle Java

Dans la programmation parallèle Java, le mécanisme de verrouillage est un outil crucial pour contrôler l'accès aux ressources partagées. Ils empêchent plusieurs threads d'accéder simultanément aux données partagées, garantissant ainsi la cohérence des données et l'exactitude du programme.

Java fournit une variété de mécanismes de verrouillage, notamment :

• Verrou intégré (synchronisé) : Les verrous intégrés sont associés à l'objet lui-même et sont obtenus en utilisant le mot-clé synchronized .
synchronized 关键字来获取。
• 显式锁 (Lock)：显式锁是 Java 并发包中提供的接口，它提供比内置锁更细粒度的控制。
• 读写锁 (ReadWriteLock)：读写锁允许多个线程同时获取共享资源的只读访问，但只能有一个线程获取写访问。

使用场景

锁机制在并行编程中有多种应用场景，包括：

• 保护共享数据免受并发访问。
• 控制对资源的访问顺序。
• 等待其他线程完成任务。

实战案例：银行账户

考虑一个银行账户的示例，它可以被多个线程并发访问。为了确保账户余额的一致性，必须使用锁来保护对此余额的访问。

使用内置锁实现的 Java 代码如下：

public class BankAccount {
    private int balance;

    public synchronized void deposit(int amount) {
        balance += amount;
    }

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

    public int getBalance() {
        return balance;
    }
}

在上面示例中，synchronized 关键字用于保护对 balance 变量的访问。任何试图访问或修改 balance

Verrouillage explicite (Lock)

 : le verrouillage explicite est une interface fournie dans le package de concurrence Java, qui offre un contrôle plus fin que les verrous intégrés. Verrouillage en lecture-écriture (ReadWriteLock)

 : le verrouillage en lecture-écriture permet à plusieurs threads d'obtenir un accès en lecture seule aux ressources partagées en même temps, mais un seul thread peut obtenir un accès en écriture.

Scénarios d'utilisation🎜🎜🎜Le mécanisme de verrouillage propose une variété de scénarios d'application en programmation parallèle, notamment : 🎜🎜🎜Protéger les données partagées contre les accès simultanés. 🎜Contrôlez l'ordre d'accès aux ressources. 🎜Attendez que d'autres discussions terminent les tâches. 🎜🎜Cas pratique : compte bancaire🎜🎜🎜Prenons l'exemple d'un compte bancaire accessible simultanément par plusieurs threads. Afin d'assurer la cohérence du solde du compte, l'accès à ce solde doit être protégé par un cadenas. 🎜🎜Le code Java implémenté à l'aide du verrou intégré est le suivant : 🎜rrreee🎜Dans l'exemple ci-dessus, le mot-clé synchronized est utilisé pour protéger l'accès à la variable balance . Tout thread qui tente d'accéder ou de modifier balance doit d'abord acquérir le verrou de l'objet. Cela garantit qu'un seul thread peut accéder à la variable à la fois. 🎜🎜🎜Conclusion🎜🎜🎜Le mécanisme de verrouillage est crucial pour la programmation parallèle Java, qui peut garantir que l'accès simultané aux ressources partagées est sûr et correct. Cet article présente les mécanismes de verrouillage fournis par Java et leurs scénarios d'application, et fournit un cas pratique pour montrer comment utiliser les verrous pour protéger les données partagées. 🎜

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!