Java Semáforos

Em Java, um semáforo é um mecanismo de sincronização de threads que permite transferir sinais entre threads para gerenciar atividades simultâneas. Ele fornece uma permissão para acessar o recurso compartilhado e, como resultado, um encadeamento deve obter permissão do semáforo para acessar os recursos. Uma aula de semáforo em Java possui construtores e métodos para controlar o acesso ao recurso compartilhado que será discutido neste artigo.

O que é semáforo

Se o contador for maior que zero, o fio terá acesso ao recurso compartilhado e o contador será decrementado por um, caso contrário, o tópico não receberá uma permissão e será suspenso. Quando a execução do tópico está concluída, o recurso não é mais necessário e o thread libera -o. O valor do contador aumentou por um depois que o recurso foi divulgado. Thread precisa obter permissão primeiro e precisa esperar antes que os recursos sejam adquiridos. O tópico não poderá compartilhar nenhum recurso se um contador atingir zero:

Agora, o código completo de execução dos threads é mencionado abaixo:

importar java.util.simultâneo.*;
importar java.util.simultâneo.Semáforo;
Classe pública Semaforclient

public static void main (string [] args)

Semáforo sem = novo semáforo (1);
// Criando dois tópicos com o nome T1 e T2
// Thread T1 irá incrementar a contagem
// Thread T2 diminuirá a contagem
Semaforethread mt1 = new Semaphorethread (SEM, "T1");
Semaforethread mt2 = new Semaphorethread (SEM, "T2");
// estaduras de estatísticas T1 e T2
mt1.começar();
mt2.começar();
tentar
// Aguardando os threads T1 e T2
mt1.juntar();
mt2.juntar();
catch (interruptedException ex)
Sistema.errar.println ("Exceção:"+ ex.getMessage ());

Sistema.fora.println ("count:" + sharedResource.contar);


classe SharedResource
estático int contagem = 0;

Semaphorethread.Java
Classe Semaforethread estende o tópico

Semáforo _sem;
String _threadName;
Public Semaphorethread (Semaphore Sem, String Thname)

Super (Thname);
esse._sem = SEM;
esse._threadName = thname;

@Sobrepor
public void run ()

se este.getName ().igual ("t1"))

Sistema.fora.println ("Iniciando" + this._threadName);
tentar

Sistema.fora.println (isso._threadName + "está esperando por uma permissão.");
// adquirindo o bloqueio
esse._sem.adquirir();
Sistema.fora.println (isso._threadName + "recebe uma permissão.");
para (int i = 0; i < 5; i++)

SharedResource.contagem ++;
Sistema.fora.println (_threadName + ":" + sharedResource.contar);
Fio.sono (20);


Catch (interruptedException exc)

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

// Libere a licença.
Sistema.fora.println (_threadname + "libera a licença.");
esse._sem.liberar();

else //// executar por thread t2

Sistema.fora.println ("Iniciando" + _threadName);
tentar

// Primeiro, obtenha uma permissão.
Sistema.fora.println (isso._threadName + "está esperando por uma permissão.");
esse._sem.adquirir();
Sistema.fora.println (_threadname + "recebe uma permissão.");
para (int i = 0; i < 5; i++)

SharedResource.contar--;
Sistema.fora.println (_threadName
+ ":" + SharedResource.contar);
Fio.sono (20);


Catch (interruptedException exc)

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

// Libere a licença.
Sistema.fora.println (_threadname + "libera a licença.");
_sem.liberar();

//correr()
//aula

Agora, no código acima, definimos três classes diferentes que são 'Semphoreclient', 'SharedResource', e 'Semaforethread'. No SemaforClient, inicializamos dois threads com uma permissão. O encadeamento T1 aumentará o contador quando executado enquanto o encadeamento T2 o diminuirá. A classe SharedResource é de onde os tópicos compartilharão o acesso. Na aula de Semaforethread, iniciamos o processo de bloqueio para ambos os threads T1 e T2, o que significa que, se algum dos dois threads bloquear o processo e começar a executar, o outro terá que esperar até que a fechadura seja liberada. Agora, antes de executar o código, você precisa ter certeza de que instalou o aplicativo Java Development Kit (JDK) em seu sistema operacional Linux usando o comando abaixo no terminal

$ sudo apt install default-jdk

Agora, após sua verificação, você pode abrir qualquer editor e depois escrever e salvar o código Java dentro dele, como mostrado abaixo.

$ nano Semaforclient.Java

O código que escrevemos dentro do 'Semaforclient.Java' O arquivo é mostrado abaixo.

Você pode ver a saída do código, como mostrado abaixo

A saída mostra que existem dois threads; Na primeira imagem, o thread T1 foi executado e, depois que o T1 libera a licença, o thread T2 começa a executar; Na segunda imagem, o thread T2 foi executado primeiro, seguido pelo thread t1. Isso implica que qualquer tópico teve a oportunidade primeiro bloqueará o processo, exigindo que o outro tópico espere.

Conclusão

Um semáforo é um objeto Java usado para controlar o acesso a um recurso compartilhado e é um método de sincronização de threads que permite enviar sinais nos threads para gerenciar várias tarefas ao mesmo tempo. Ele concede acesso ao recurso compartilhado e, como resultado, um tópico deve primeiro obter permissão do semáforo antes de usar os recursos. Neste artigo, criamos dois threads A e B com uma licença. Portanto, qualquer um desses dois tópicos começará a executar e bloquear o processo, então o outro tópico precisa esperar até que o processo seja liberado.