Quel est le rôle du sémaphore dans la concurrence des fonctions Java et le multithreading ?

Semaphore est un mécanisme de contrôle de l'accès aux ressources multithread dans la programmation simultanée Java. Il est implémenté en créant une licence. Le nombre de licences est spécifié lors de l'initialisation, indiquant le nombre de ressources protégées auxquelles un thread peut accéder en même temps. un thread tente d'accéder à une ressource, il essaiera d'obtenir une licence, si aucune licence n'est disponible, le thread sera bloqué jusqu'à ce qu'une licence soit disponible.

Le rôle du sémaphore dans la concurrence des fonctions Java et le multi-threading

Le sémaphore est un mécanisme important dans la programmation simultanée Java, utilisé pour contrôler l'accès aux ressources dans des scénarios multi-thread. Pour ce faire, il crée des licences pour les structures de données partagées qui protègent les ressources.

Comment ça marche

Semaphore spécifie un nombre de licences lors de son initialisation, qui indique le nombre maximum de threads pouvant accéder aux ressources protégées en même temps. Lorsqu'un thread tente d'accéder à une ressource, il tente d'obtenir une licence sur le sémaphore. Si disponible, la licence est accordée et le thread peut accéder à la ressource. Si aucune licence n'est disponible, le fil de discussion sera bloqué jusqu'à ce qu'une licence soit disponible.

Cas pratique

Supposons que nous ayons une ressource partagée, c'est-à-dire une file d'attente. Seuls 5 threads peuvent accéder simultanément à la file d’attente. On peut utiliser un Sémaphore pour s'en assurer :

import java.util.concurrent.Semaphore;
import java.util.Queue;

public class Example {
    private static final int MAX_ACCESS_COUNT = 5;
    private static Semaphore semaphore = new Semaphore(MAX_ACCESS_COUNT);
    private static Queue<Integer> queue = new ConcurrentLinkedQueue<>();

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> accessQueue()).start();
        }
    }

    private static void accessQueue() {
        try {
            // 尝试获取一个许可证
            semaphore.acquire();

            // 访问队列
            queue.add((int) (Math.random() * 100));

            // 释放许可证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Dans cet exemple, le sémaphore est initialisé avec 5 licences. Cela garantit que seuls un maximum de 5 threads peuvent accéder simultanément à la file d’attente. Les autres discussions seront bloquées jusqu'à ce qu'une licence soit disponible.

Conclusion

Semaphore est très utile pour contrôler l'accès simultané aux ressources partagées. Il permet d'éviter les courses de données et les incohérences en limitant le nombre de threads pouvant accéder simultanément à une ressource.

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!