Java semafores

I Java er en semafor en trådsynkroniseringsmekanisme som lar deg overføre signaler på tvers av tråder for å administrere samtidige aktiviteter. Det gir tillatelse til å få tilgang til den delte ressursen, og som et resultat må en tråd få tillatelse fra semaforen for å få tilgang til ressursene. En semaforklasse i Java har i tillegg konstruktører og metoder for å kontrollere tilgangen til den delte ressursen som vil bli diskutert i denne artikkelen.

Hva er semafor

Hvis telleren er større enn null, får tråden tilgang til den delte ressursen, og telleren er dekrementert av en, ellers får tråden ikke en tillatelse og vil bli suspendert. Når trådens utførelse er fullført, er ikke ressursen lenger nødvendig, og tråden slipper den. Tellerverdien økte med en når ressursen ble utgitt. Tråden må først få tillatelse og må vente før ressursene skal anskaffes. Tråden vil ikke kunne dele noen ressurser hvis en teller når null:

Nå er den komplette utførelseskoden nevnt nedenfor:

Importer Java.util.samtidig.*;
Importer Java.util.samtidig.Semafor;
Public Class SemaphoreClient

public static void main (String [] args)

Semaphore SEM = ny semafor (1);
// lage to tråder med navn T1 og T2
// Tråd T1 øker antallet
// Tråd T2 vil redusere tellingen
Semaphorethread mt1 = new Semaphorethread (SEM, "T1");
Semaphorethread mt2 = new Semaphorethread (SEM, "T2");
// Stat Threads T1 og T2
MT1.start();
MT2.start();
prøv
// venter på tråder T1 og T2
MT1.bli med();
MT2.bli med();
fangst (interruptedException ex)
System.feil.println ("Unntak:"+ eks.getMessage ());

System.ute.Println ("Count:" + SharedResource.telle);


klasse SharedResource
statisk int count = 0;

Semaphorethread.Java
Klassesemaphorethread utvider tråden

Semafor _sem;
Streng _ThreadName;
public Semaphorethread (Semaphore SEM, String Thname)

super (thname);
dette._SEM = SEM;
dette._ThreadName = Thname;

@Overstyring
public void Run ()

hvis dette.getName ().lik ("T1"))

System.ute.println ("starter" + dette._ThreadName);
prøve

System.ute.Println (dette._ThreadName + "venter på tillatelse.");
// anskaffe låsen
dette._sem.tilegne();
System.ute.Println (dette._ThreadName + "får tillatelse.");
for (int i = 0; i < 5; i++)

SharedResource.telle ++;
System.ute.Println (_ThreadName + ":" + SharedResource.telle);
Tråd.søvn (20);


Catch (InterruptException EXC)

System.ute.Println (Exc.getMessage ());

// frigjør tillatelsen.
System.ute.Println (_ThreadName + "slipper tillatelsen.");
dette._sem.utgivelse();

annet //// Kjør av tråd T2

System.ute.println ("Start" + _ThreadName);
prøve

// Først, få tillatelse.
System.ute.Println (dette._ThreadName + "venter på tillatelse.");
dette._sem.tilegne();
System.ute.Println (_ThreadName + "får tillatelse.");
for (int i = 0; i < 5; i++)

SharedResource.telle--;
System.ute.Println (_ThreadName
+ ":" + SharedResource.telle);
Tråd.søvn (20);


Catch (InterruptException EXC)

System.ute.Println (Exc.getMessage ());

// frigjør tillatelsen.
System.ute.Println (_ThreadName + "slipper tillatelsen.");
_sem.utgivelse();

//løpe()
//klasse

Nå i koden ovenfor har vi definert tre forskjellige klasser som er 'Semphoreclient', 'SharedResource', og 'Semaphorethread'. I semaphoreclient har vi initialisert to tråder med en tillatelse. Tråd T1 øker telleren når den utføres mens tråd T2 vil redusere den. SharedResource -klassen er hvor trådene vil dele tilgang. I Semaphorethread -klassen har vi satt i gang låsingsprosessen for både trådene T1 og T2, noe som betyr at hvis noen av de to trådene låser prosessen og begynner å utføre, må den andre vente til låsen er utgitt. Nå før du utfører koden, må du sørge for at du først har installert Java Development Kit (JDK) -applikasjonen i Linux -operativsystemet ved å bruke kommandoen nedenfor i terminalen

$ sudo apt install standard-jdk

Nå etter bekreftelsen, kan du åpne hvilken som helst redigerer og deretter skrive og lagre Java -koden inne i den som vist nedenfor.

$ nano semaphoreclient.Java

Koden som vi har skrevet inne i 'Semaphoreclient.java ' Filen vises nedenfor.

Du kan se utdataene fra koden som vist nedenfor

Utgangen viser at det er to tråder; I det første bildet er tråd T1 blitt utført, og når T1 først slipper tillatelsen, begynner tråd T2 å utføre; I det andre bildet har tråd T2 blitt utført først, etterfulgt av tråd T1. Dette innebærer at hvilken tråd som hadde muligheten først vil låse prosessen, og krever at den andre tråden skulle vente.

Konklusjon

En semafor er et Java -objekt som brukes til å kontrollere tilgangen til en delt ressurs, og det er en trådsynkroniseringsmetode som lar deg sende signaler over tråder for å administrere flere oppgaver samtidig. Det gir tilgang til den delte ressursen, og som et resultat må en tråd først få tillatelse fra semaforen før han bruker ressursene. I denne artikkelen har vi laget to tråder A og B med en tillatelse. Så noen av disse to trådene vil begynne å utføre og låse prosessen, så må den andre tråden vente til prosessen er utgitt.