En Java, on utilise le sémaphore dans la synchronisation des fils. Il est utilisé pour contrôler l’accès à une ressource partagée qui utilise une variable de compteur. Java fournit également une classe Sémaphore qui contient des constructeurs et diverses méthodes pour contrôler l’accès sur la ressource partagée. Nous en discuterons plus tard dans cette section.

Avant d’avancer dans cette section, nous allons d’abord comprendre ce qu’est le sémaphore, les types de sémaphore, comment il fonctionne et comment mettre en œuvre le sémaphore. Après avoir tout su, nous passerons aux programmes de sémaphore Java.

Qu’est-ce qu’un sémaphore?

Un sémaphore est utilisé pour limiter le nombre de threads qui veulent accéder à une ressource partagée. En d’autres termes, c’est une variable non négative partagée entre les threads connue sous le nom de compteur. Elle fixe la limite des threads. Un mécanisme dans lequel un thread est en attente sur un sémaphore peut être signalé par d’autres threads.

• Si le compteur > 0, l’accès aux ressources partagées est fourni.
• Si le compteur = 0, l’accès aux ressources partagées est refusé.

En bref, le compteur garde la trace du nombre de permissions qu’il a données à une ressource partagée. Par conséquent, le sémaphore accorde la permission aux threads de partager une ressource.

Caractéristiques du sémaphore

Il y a les caractéristiques suivantes d’un sémaphore:

• Il fournit une synchronisation entre les threads.
• Il diminue le niveau de synchronisation. Par conséquent, fournit un mécanisme de synchronisation de bas niveau.
• Le sémaphore ne contient pas de valeur négative. Il détient une valeur qui peut être soit supérieure à zéro, soit égale à zéro.
• Nous pouvons mettre en œuvre le sémaphore en utilisant l’opération de test et les interruptions, et nous utilisons les descripteurs de fichiers pour l’exécuter.

Fonctionnement du sémaphore

Le sémaphore contrôle la ressource partagée à travers une variable de compteur. Le compteur est une valeur non négative. Il contient une valeur soit supérieure à 0, soit égale à 0.

• Si le compteur > 0, le thread obtient la permission d’accéder à la ressource partagée et la valeur du compteur est décrémentée de 1.
• Sinon, le thread sera bloqué jusqu’à ce qu’une permission puisse être acquise.
• Lorsque l’exécution du thread est terminée alors il n’y a plus besoin de la ressource et le thread la libère. Après avoir libéré la ressource, la valeur du compteur est incrémentée de 1.
• Si un autre thread attend pour acquérir une ressource, le thread acquerra un permis à ce moment-là.
• Si le compteur = 0, le thread n’obtient pas la permission d’accéder à la ressource partagée.

Comprenons le fonctionnement du sémaphore à l’aide d’un organigramme.

Types de sémaphores

Il existe quatre types de sémaphores, qui sont les suivants :

• Sémaphores de comptage
• Sémaphores bornés
• Sémaphores temporisés
• Sémaphores binaires

Détaillons-les un par un.

Sémaphores de comptage

Les sémaphores de comptage sont utilisés pour résoudre la situation dans laquelle plus d’un processus veut s’exécuter dans la section critique, simultanément. Donc, pour surmonter ce problème, nous utilisons le sémaphore de comptage. Par exemple, considérez l’extrait de code suivant.

Voyons la mise en œuvre des sémaphores de comptage.

CountingSemaphoresExample.java

Sémaphores bornés

Nous pouvons définir la limite supérieure en utilisant les sémaphores bornés. Il est utilisé à la place des sémaphores de comptage car ces derniers ne contiennent pas de valeur de limite supérieure. La valeur de la limite supérieure indique le nombre de signaux qu’il peut stocker. Par exemple, considérez le bout de code suivant.

Voyons l’implémentation du sémaphore borné.

BoundedSemaphoresExample.java

Sémaphores temporisés

Les sémaphores temporisés permettent à un thread de fonctionner pendant une période de temps spécifiée. Après un temps particulier, le minuteur se réinitialise et libère tous les autres permis.

Voyons l’implémentation des sémaphores temporisés.

TimedSemaphoresExample.java

Sémaphores binaires

Les sémaphores binaires sont les mêmes que les sémaphores de comptage. Mais rappelez-vous qu’il n’accepte que des valeurs binaires soit 0 ou 1. Sa mise en œuvre est facile par rapport aux autres sémaphores. Si la valeur est 1, l’opération de signalisation est un succès, échoue sinon.

Voyons la mise en œuvre des sémaphores binaires.

BinarySemaphoresExample.java

Semaphore en Java

En Java, c’est une construction de synchronisation de threads. La construction utilise une variable connue comme un compteur qui contrôle l’accès sur la ressource partagée. C’est un type de variable qui est utilisé pour gérer les processus concurrents et aussi les synchroniser. Il est également utilisé pour éviter les conditions de course. Il restreint le nombre de threads pour accéder à une ressource partagée.

Par exemple, nous pouvons restreindre un fichier pour accéder jusqu’à 10 connexions simultanément.

Java Semaphore Class

Java fournit une classe Semaphore pour mettre en œuvre le mécanisme de sémaphore. Elle appartient au paquet java.util.concurrent. Elle implémente l’interface Serializable. Par conséquent, une implémentation manuelle n’est pas nécessaire.

La classe Sémaphore fournit les deux constructeurs suivants :

• Semaphore(int permis)
• Semaphore(int permis, boolean fair)

Semaphore(int permis)

Il crée un Sémaphore et analyse le nombre de permis (nombre initial de permis disponibles) comme argument. Il spécifie le nombre de threads qui peuvent partager une ressource à un moment donné. La valeur des permis peut être négative. Dans ce cas, une libération doit se produire avant que toute acquisition soit accordée.

Syntaxe:

Semaphore(int permis, boolean fair)

Il crée un sémaphore avec le nombre de permis et les paramètres d’équité donnés.

Syntaxe:

Il analyse deux paramètres:

• permis : La valeur de permis peut être négative. Dans ce cas, la libération doit se produire avant que les acquisitions ne soient accordées.
• équitable : Si nous fixons la valeur à true, le sémaphore garantit le FIFO aux threads dans l’ordre où ils sont demandés, false Par défaut, tous les threads qui attendent la ressource accorde des permis dans un ordre indéfini.

Méthodes de la classe sémaphore

La classe fournit les méthodes suivantes :

méthode acquire() : La méthode acquiert les permis du sémaphore, en bloquant jusqu’à ce qu’un permis soit disponible, ou que le thread soit interrompu. Elle réduit le nombre de permis disponibles de 1.

Si aucun permis n’est disponible pour le thread actuel, le thread devient désactivé à des fins d’ordonnancement du thread. Le thread actuel passe dans l’état inactif jusqu’à ce qu’une des deux choses suivantes se produise :

• Si l’autre thread invoque la méthode release() pour libérer la ressource alors le thread actuel obtient des permis.
• Si l’autre thread interrompt le thread actuel.

Il jette InterruptedException si le thread actuel est interrompu. La méthode ne renvoie aucune valeur.

Syntaxe:

méthoderelease() : Elle libère un permis et le renvoie au sémaphore. Elle incrémente le nombre de permis disponibles de 1. Si un thread tente d’acquérir un permis, le sémaphore accorde la permission d’acquérir la ressource qui vient d’être libérée par d’autres threads. De plus, ce thread est considéré à des fins d’ordonnancement des threads.

Syntaxe:

MéthodeavailablePermits() : Cette méthode renvoie le nombre de permis disponibles dans le sémaphore pour l’octroi de la ressource. Habituellement, elle est utilisée à des fins de débogage et de test.

Syntaxe:

Comprenons les méthodes ci-dessus par un exemple simple.

Utilisation du sémaphore comme verrou

Java nous permet d’utiliser un sémaphore comme verrou. Cela signifie qu’il verrouille l’accès à la ressource. Tout thread qui veut accéder à la ressource verrouillée, doit appeler la méthode acquire() avant d’accéder à la ressource pour acquérir le verrou. Le thread doit libérer le verrou en appelant la méthode release(), après l’achèvement de la tâche. N’oubliez pas que la limite supérieure est fixée à 1. Par exemple, considérez l’extrait de code suivant:

Voyons un exemple de sémaphore et utilisons le sémaphore comme verrou.

SemaphoreAsLock.java

Sortie:

Note : Lorsque nous exécutons le programme ci-dessus, nous obtenons une sortie différente à chaque fois. Donc, votre sortie peut être différente de celle indiquée ci-dessus.

Exemple de sémaphore Java

Comprenons le mécanisme de sémaphore à travers un programme Java. Dans l’exemple suivant, nous avons créé un constructeur de la classe Sémaphore avec la valeur initiale du permis 3.

SemaphoreExample.java

Sortie:

.