Java -Semaphoren

In Java ist ein Semaphor ein Mechanismus der Fadensynchronisation, mit dem Sie Signale über Threads hinweg übertragen können, um gleichzeitige Aktivitäten zu verwalten. Es bietet eine Erlaubnis, auf die gemeinsame Ressource zuzugreifen, und infolge. Eine Semaphor -Klasse in Java verfügt außerdem über Konstruktoren und Methoden zur Kontrolle des Zugriffs auf die gemeinsame Ressource, die in diesem Artikel erörtert wird.

Was ist Semaphor

Wenn der Zähler größer als Null ist, wird dem Thread Zugriff auf die gemeinsame Ressource gewährt, und der Zähler wird durch eins abgeschlossen, da ansonsten der Thread keine Genehmigung erhält und suspendiert wird. Wenn die Ausführung des Threads abgeschlossen ist, ist die Ressource nicht mehr erforderlich, und der Thread veröffentlicht sie. Der Zählerwert erhöhte sich um eins, sobald die Ressource veröffentlicht wurde. Der Thread muss zuerst die Erlaubnis einholen und warten, bis die Ressourcen erworben werden müssen. Der Thread kann keine Ressourcen teilen, wenn ein Zähler Null erreicht:

Jetzt wird der vollständige Code der Thread -Ausführung nachstehend erwähnt:

Java importieren.Util.gleichzeitig.*;
Java importieren.Util.gleichzeitig.Semaphor;
öffentliche Klasse Semaphoreclient

öffentliche statische Leere Main (String [] Args)

Semaphor SEM = neues Semaphor (1);
// Erstellen Sie zwei Threads mit Namen T1 und T2
// Thread T1 erhöht die Anzahl
// Thread T2 verringert die Anzahl
Semaphorethread mt1 = neuer semaphorethread (sem, "t1");
Semaphorethread mt2 = neuer semaphorethread (sem, "t2");
// STAT -Threads T1 und T2
MT1.Start();
MT2.Start();
versuchen
// Warten auf Threads T1 und T2
MT1.verbinden();
MT2.verbinden();
catch (InterruptedException ex)
System.irren.println ("Ausnahme:"+ ex.getMessage ());

System.aus.println ("Graf:" + SharedResource.zählen);


Klasse SharedResource
statische int count = 0;

Semaphorethread.Java
Klasse Semaphorethread erweitert Thread

Semaphor _sem;
String _ThreadName;
Öffentliche Semaphorethead (Semaphore SEM, String Thhname)

Super (Thhname);
Das._sem = sem;
Das._ThreadName = Thhname;

@Override
öffentliche void run ()

if (das.GetName ().gleich ("t1"))

System.aus.println ("starten" + das._ThreadName);
versuchen

System.aus.println (dies._Threadname + "wartet auf eine Erlaubnis.");
// das Schloss erwerben
Das._Sem.erwerben();
System.aus.println (dies._Threadname + "erhält eine Erlaubnis.");
für (int i = 0; i < 5; i++)

SharedResource.zählen ++;
System.aus.println (_threadname + ":" + SharedResource.zählen);
Gewinde.Schlaf (20);


Catch (InterruptedException exc)

System.aus.println (exc.getMessage ());

// die Genehmigung freigeben.
System.aus.println (_threadname + "veröffentlicht die Genehmigung.");
Das._Sem.freigeben();

sonst //// von Thread T2 ausführen

System.aus.println ("starten" + _threadname);
versuchen

// Erstens eine Erlaubnis erhalten.
System.aus.println (dies._Threadname + "wartet auf eine Erlaubnis.");
Das._Sem.erwerben();
System.aus.println (_threadname + "erhält eine Erlaubnis.");
für (int i = 0; i < 5; i++)

SharedResource.zählen--;
System.aus.println (_threadname
+ ":" + SharedResource.zählen);
Gewinde.Schlaf (20);


Catch (InterruptedException exc)

System.aus.println (exc.getMessage ());

// die Genehmigung freigeben.
System.aus.println (_threadname + "veröffentlicht die Genehmigung.");
_Sem.freigeben();

//laufen()
//Klasse

Jetzt im obigen Code haben wir drei verschiedene Klassen definiert, die sind "Semphoreclient", "SharedResource", Und "Semaphorethead". In Semaphoreclient haben wir zwei Threads mit einer Berechtigung initialisiert. Thread T1 erhöht den Zähler, wenn Thread T2 ausgeführt wird. Die SharedResource -Klasse stammt aus dem Ort, an dem die Threads zugreifen können. In der Semaphorethread -Klasse haben wir den Sperrvorgang für beide Threads T1 und T2 eingeleitet, was bedeutet. Bevor Sie den Code ausführen, müssen Sie zunächst sicherstellen

$ sudo apt installieren Standard-JDK

Jetzt nach seiner Überprüfung können Sie jeden Editor öffnen und dann den Java -Code wie unten gezeigt schreiben und speichern.

$ nano semaphoreclient.Java

Der Code, den wir in der geschrieben haben 'Semaphoreclient.Java' Die Datei ist unten angezeigt.

Sie können die Ausgabe des Codes wie unten gezeigt sehen

Die Ausgabe zeigt, dass es zwei Threads gibt; Im ersten Bild wurde Thread T1 ausgeführt, und sobald T1 die Genehmigung freigibt, beginnt Thread T2 auszuführen. Im zweiten Bild wurde Thread T2 zuerst ausgeführt, gefolgt von Thread T1. Dies impliziert, dass jeder Thread die Gelegenheit hatte, zuerst den Prozess zu sperren und den anderen Thread zu warten erfordert.

Abschluss

Ein Semaphor ist ein Java -Objekt, mit dem der Zugriff auf eine gemeinsam genutzte Ressource gesteuert wird. Es handelt sich um eine Thread -Synchronisierungsmethode, mit der Sie Signale über Threads hinweg senden, um mehrere Aufgaben gleichzeitig zu verwalten. Es gewährt Zugriff auf die gemeinsame Ressource. Infolgedessen muss ein Thread zuerst die Berechtigung aus dem Semaphor erhalten. In diesem Artikel haben wir zwei Threads A und B mit einer Genehmigung erstellt. Daher wird jeder dieser beiden Threads mit der Ausführung und dem Sperrung des Vorgangs beginnt, dann muss der andere Thread warten, bis der Vorgang veröffentlicht wird.