Comment utiliser les verrous et les synchroniseurs dans la programmation simultanée Java ?

Java fournit des verrous et des synchroniseurs pour gérer l'accès aux ressources partagées. Les verrous tels que ReentrantLock permettent à un seul thread d'accéder à une section critique à la fois, tandis que les synchroniseurs tels que Semaphore et CountDownLatch offrent un contrôle de concurrence plus flexible, comme limiter le nombre de threads accédant simultanément à une ressource ou attendre que tous les threads terminent leurs tâches. . L’utilisation de ces mécanismes peut efficacement éviter les courses aux données et améliorer les performances des applications.

Verrous et synchroniseurs dans la programmation simultanée Java

La programmation simultanée permet à plusieurs threads de s'exécuter simultanément, mais nécessite des mécanismes pour gérer l'accès aux ressources partagées. Java fournit divers verrous et synchroniseurs pour y parvenir.

Verrous

Les verrous permettent à un seul thread d'accéder à la section critique (partie modifiée d'une ressource partagée) à la fois. Les verrous couramment utilisés sont :

// 创建一个 ReentrantLock
Lock lock = new ReentrantLock();

// 获取锁
lock.lock();

// 访问临界区
// ...

// 释放锁
lock.unlock();

Synchronizer

Les synchroniseurs sont plus avancés que les verrous et offrent un contrôle de concurrence plus flexible. Les synchroniseurs couramment utilisés sont :

Semaphore

Semaphore limite le nombre de threads pouvant accéder aux ressources en même temps.

// 创建一个 Semaphore，允许最多 3 个线程同时访问
Semaphore semaphore = new Semaphore(3);

// 申请许可证
semaphore.acquire();

// 访问临界区
// ...

// 释放许可证
semaphore.release();

CountDownLatch

CountDownLatch attend que tous les threads terminent leurs tâches avant de continuer.

// 创建一个 CountDownLatch，等待 10 个线程完成
CountDownLatch latch = new CountDownLatch(10);

// 10 个线程执行任务
// ...

// 每个线程完成后，计数器减一
latch.countDown();

// 主线程等待所有线程完成
latch.await();

Cas pratique

Ce qui suit est un cas pratique de fonctionnement d'un compte bancaire, utilisant Sémaphore pour limiter le nombre de threads accédant au compte en même temps :

class BankAccount {
    private Semaphore semaphore = new Semaphore(1);
    private double balance;

    public void deposit(double amount) {
        try {
            semaphore.acquire();
            balance += amount;
        } finally {
            semaphore.release();
        }
    }

    public void withdraw(double amount) {
        try {
            semaphore.acquire();
            balance -= amount;
        } finally {
            semaphore.release();
        }
    }
}

Conclusion

Les verrous et synchroniseurs sont utilisés pour gérer l'accès aux ressources partagées dans un outil puissant de programmation simultanée Java. En utilisant ces mécanismes avec précaution, vous pouvez efficacement éviter les courses aux données et améliorer les performances des programmes.

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!