Semaphores Java

En Java, un sémaphore est un mécanisme de synchronisation des threads qui vous permet de transférer des signaux à travers les threads pour gérer les activités simultanées. Il fournit un permis pour accéder à la ressource partagée et, par conséquent, un fil doit obtenir l'autorisation du sémaphore pour accéder aux ressources. Une classe de sémaphore à Java a en outre des constructeurs et des méthodes pour contrôler l'accès à la ressource partagée qui sera discutée dans cet article.

Qu'est-ce que le sémaphore

Si le compteur est supérieur à zéro, le thread a accès à la ressource partagée, et le compteur est décrémenté, sinon, le fil n'obtiendra pas de permis et sera suspendu. Lorsque l'exécution du thread est terminée, la ressource n'est plus nécessaire et le thread le libère. La valeur de comptoir a augmenté de une fois la ressource libérée. Le thread doit d'abord obtenir la permission et doit attendre avant les ressources à acquérir. Le fil ne pourra pas partager des ressources si un compteur atteint zéro:

Maintenant, le code complet de l'exécution des threads est mentionné ci-dessous:

Importer Java.user.concurrent.*
Importer Java.user.concurrent.Sémaphore;
Semaphoreclient de classe publique

public static void main (String [] args)

Semaphore SEM = nouveau sémaphore (1);
// Création de deux threads avec le nom T1 et T2
// Thread T1 augmentera le nombre
// Thread T2 diminuera le nombre
SemaphoreThread MT1 = nouveau SemaphoreThread (SEM, "T1");
SemaphoreThread MT2 = nouveau SemaphoreThread (SEM, "T2");
// Threads Stat T1 et T2
MT1.commencer();
mt2.commencer();
essayer
// en attente de threads T1 et T2
MT1.rejoindre();
mt2.rejoindre();
catch (InterruptedException ex)
Système.se tromper.println ("Exception:" + ex.getMessage ());

Système.dehors.println ("Count:" + SharedResource.compter);


class SharedResource
statique int count = 0;

Sémaphoretheread.Java
Class SemaphoreThread étend le fil

Semaphore _Sem;
String _ThreadName;
SemaphoreThread public (Semaphore SEM, String Thname)

super (thname);
ce._Sem = SEM;
ce._ThreadName = thname;

@Passer outre
public void run ()

si ce.getName ().égaux ("t1"))

Système.dehors.println ("démarrer" + ceci._ThreadName);
essayer

Système.dehors.println (ceci._Threadname + "attend un permis.");
// Acquérir le verrouillage
ce._sem.acquérir();
Système.dehors.println (ceci._Threadname + "obtient un permis.");
pour (int i = 0; i < 5; i++)

PartagerResource.Count ++;
Système.dehors.println (_Threadname + ":" + SharedResource.compter);
Fil.sommeil (20);


Catch (InterruptedException exc)

Système.dehors.println (exc.getMessage ());

// libérer le permis.
Système.dehors.println (_threadname + "libère le permis.");
ce._sem.libérer();

else //// exécuté par thread t2

Système.dehors.println ("démarrage" + _ThreadName);
essayer

// Tout d'abord, obtenez un permis.
Système.dehors.println (ceci._Threadname + "attend un permis.");
ce._sem.acquérir();
Système.dehors.println (_threadname + "obtient un permis.");
pour (int i = 0; i < 5; i++)

PartagerResource.compter--;
Système.dehors.println (_threadname
+ ":" + SharedResource.compter);
Fil.sommeil (20);


Catch (InterruptedException exc)

Système.dehors.println (exc.getMessage ());

// libérer le permis.
Système.dehors.println (_threadname + "libère le permis.");
_sem.libérer();

//courir()
//classe

Maintenant dans le code ci-dessus, nous avons défini trois classes différentes qui sont 'Semphoreclient', 'SharedResource', et 'Semaphorethread'. En sémaphoreclient, nous avons initialisé deux fils avec une permission. Le thread T1 incrémentera le compteur lors de l'exécution tandis que le thread T2 le diminuera. La classe SharedResource est à partir d'où les threads partageront l'accès. Dans la classe SemaphoreThread, nous avons lancé le processus de verrouillage pour les threads T1 et T2, ce qui signifie que si l'un des deux threads verrouille le processus et commence à s'exécuter, l'autre doit attendre que le verrou a été publié. Maintenant, avant d'exécuter le code, vous devez d'abord vous assurer que vous avez installé l'application Java Development Kit (JDK) dans votre système d'exploitation Linux en utilisant la commande ci-dessous dans le terminal

$ sudo apt installer par défaut-jdk

Maintenant, après sa vérification, vous pouvez ouvrir n'importe quel éditeur, puis écrire et enregistrer le code Java à l'intérieur comme indiqué ci-dessous.

$ nano sémaphoreclient.Java

Le code que nous avons écrit à l'intérieur du 'Semaphoreclient.Java' Le fichier est affiché ci-dessous.

Vous pouvez voir la sortie du code comme indiqué ci-dessous

La sortie montre qu'il y a deux threads; Dans la première image, le thread T1 a été exécuté, puis une fois que T1 libère le permis, le thread T2 commence à s'exécuter; Dans la deuxième image, le thread T2 a été exécuté en premier, suivi du thread T1. Cela implique que tout le fil a eu l'occasion d'abord verrouiller le processus, obligeant l'autre fil à attendre.

Conclusion

Un sémaphore est un objet Java qui est utilisé pour contrôler l'accès à une ressource partagée et c'est une méthode de synchronisation de threads qui vous permet d'envoyer des signaux à travers les threads pour gérer plusieurs tâches en même temps. Il accorde l'accès à la ressource partagée et, par conséquent, un fil doit d'abord obtenir l'autorisation du sémaphore avant d'utiliser les ressources. Dans cet article, nous avons créé deux fils A et B avec un permis. Ainsi, tous ces deux threads commenceront à exécuter et verrouiller le processus, alors l'autre thread doit attendre que le processus soit libéré.