Java Semafores

In Java, un semaforo è un meccanismo di sincronizzazione del thread che consente di trasferire segnali tra i thread per gestire le attività concorrenti. Fornisce un permesso per accedere alla risorsa condivisa e, di conseguenza, un thread deve ottenere l'autorizzazione dal semaforo per accedere alle risorse. Una classe di semaforo in Java ha inoltre costruttori e metodi per controllare l'accesso alla risorsa condivisa che sarà discussa in questo articolo.

Cos'è il semaforo

Se il contatore è maggiore di zero, il thread viene concesso l'accesso alla risorsa condivisa e il contatore viene decrementato da uno, altrimenti il ​​thread non riceverà un permesso e verrà sospeso. Quando l'esecuzione del thread è completa, la risorsa non è più richiesta e il thread la rilascia. Il valore contatore è aumentato di uno una volta che la risorsa è stata rilasciata. Il thread deve prima ottenere l'autorizzazione e deve attendere prima che le risorse vengano acquisite. Il thread non sarà in grado di condividere alcuna risorsa se un contatore raggiunge zero:

Ora è menzionato il codice completo di esecuzione dei thread:

Importa Java.util.simultaneo.*;
Importa Java.util.simultaneo.Semaforo;
Semaforeclient di classe pubblica

public static void main (string [] args)

Semaforo SEM = new Semaphore (1);
// Creazione di due thread con il nome T1 e T2
// thread T1 increverà il conteggio
// thread t2 diminuirà il conteggio
SemaforeThread mt1 = new semaforeThread (SEM, "T1");
SemaforeThread MT2 = new SemaphoreThread (SEM, "T2");
// thread stat t1 e t2
MT1.inizio();
MT2.inizio();
Tentativo
// in attesa di thread T1 e T2
MT1.giuntura();
MT2.giuntura();
catch (interruptedException ex)
Sistema.err.println ("eccezione:"+ ex.getMessage ());

Sistema.fuori.println ("conta:" + sharedResource.contare);


Classe SharedResource
static int count = 0;

SemaforeTread.Giava
SemaforeThread di classe estende il thread

Semaforo _sem;
String _ThreadName;
SemaforeThread pubblico (semaforo SEM, String thname)

super (thname);
Questo._sem = sem;
Questo._ThreadName = thname;

@Oltrepassare
public void run ()

se questo.getName ().equals ("t1"))

Sistema.fuori.println ("iniziale" + questo._ThreadName);
Tentativo

Sistema.fuori.println (questo._ThreadName + "è in attesa di un permesso.");
// Acquisizione del blocco
Questo._sem.acquisire();
Sistema.fuori.println (questo._ThreadName + "ottiene un permesso.");
per (int i = 0; i < 5; i++)

SharedResource.conta ++;
Sistema.fuori.println (_ThreadName + ":" + SharedResource.contare);
Filo.sonno (20);


Catch (InterruptedException Exc)

Sistema.fuori.println (exc.getMessage ());

// Rilascia il permesso.
Sistema.fuori.println (_ThreadName + "rilascia il permesso.");
Questo._sem.pubblicazione();

else //// eseguito da thread t2

Sistema.fuori.println ("avvio" + _ThreadName);
Tentativo

// Innanzitutto, ottieni un permesso.
Sistema.fuori.println (questo._ThreadName + "è in attesa di un permesso.");
Questo._sem.acquisire();
Sistema.fuori.println (_ThreadName + "ottiene un permesso.");
per (int i = 0; i < 5; i++)

SharedResource.contare--;
Sistema.fuori.println (_ThreadName
+ ":" + SharedResource.contare);
Filo.sonno (20);


Catch (InterruptedException Exc)

Sistema.fuori.println (exc.getMessage ());

// Rilascia il permesso.
Sistema.fuori.println (_ThreadName + "rilascia il permesso.");
_sem.pubblicazione();

//correre()
//classe

Ora nel codice sopra, abbiamo definito tre diverse classi che sono 'Semforeclient', 'SharedResource', E 'SemaforeThread'. In semaforeclient abbiamo inizializzato due thread con un permesso. Thread t1 increscerà il contatore quando eseguito mentre il thread t2 lo diminuirà. La classe SharedResource è da dove i thread condivideranno l'accesso. Nella classe semaforeThread, abbiamo avviato il processo di blocco per entrambi i thread T1 e T2, il che significa che se una delle due thread bloccano il processo e inizia a eseguire, l'altro deve aspettare fino a quando il blocco non è stato rilasciato. Ora prima di eseguire il codice, è necessario assicurarsi prima di aver installato l'applicazione Java Development Kit (JDK) nel sistema operativo Linux utilizzando il comando di seguito nel terminale

$ sudo apt installare default-jdk

Ora dopo la sua verifica, puoi aprire qualsiasi editor, quindi scrivere e salvare il codice Java al suo interno come mostrato di seguito.

$ nano semaforeclient.Giava

Il codice che abbiamo scritto all'interno del 'Semaforeclient.Giava' Il file è mostrato di seguito.

Puoi vedere l'output del codice come mostrato di seguito

L'output mostra che ci sono due thread; Nella prima immagine, il thread T1 è stato eseguito, quindi una volta che T1 rilascia il permesso, il thread T2 inizia a eseguire; Nella seconda immagine, il thread T2 è stato eseguito per primo, seguito dal thread T1. Ciò implica che qualunque thread abbia avuto l'opportunità per prima bloccerà il processo, richiedendo all'altro thread di aspettare.

Conclusione

Un semaforo è un oggetto Java che viene utilizzato per controllare l'accesso a una risorsa condivisa ed è un metodo di sincronizzazione del thread che consente di inviare segnali su thread per gestire diverse attività contemporaneamente. Concede l'accesso alla risorsa condivisa e, di conseguenza, un thread deve prima ottenere l'autorizzazione dal semaforo prima di utilizzare le risorse. In questo articolo, abbiamo creato due thread A e B con un permesso. Quindi uno di questi due thread inizierà a eseguire e bloccare il processo, quindi l'altro thread deve attendere fino al rilascio del processo.