Semáforos de Java

En Java, un semáforo es un mecanismo de sincronización de subprocesos que le permite transferir señales a través de subprocesos para administrar actividades concurrentes. Proporciona un permiso para acceder al recurso compartido y, como resultado, un hilo debe obtener permiso del semáforo para acceder a los recursos. Una clase semáforo en Java también tiene constructores y métodos para controlar el acceso al recurso compartido que se discutirá en este artículo.

Que es semáforo

Si el contador es mayor que cero, el hilo se otorga acceso al recurso compartido, y el contador está disminuido por uno, de lo contrario, el hilo no obtendrá un permiso y se suspenderá. Cuando se completa la ejecución del hilo, el recurso ya no se requiere y el hilo lo libera. El valor del contador aumentó en uno una vez que se liberó el recurso. El hilo debe obtener permiso primero y debe esperar antes de adquirir recursos. El hilo no podrá compartir ningún recurso si un contador alcanza cero:

Ahora se menciona a continuación el código completo de la ejecución de los subprocesos:

importar java.utilizar.concurrente.*;
importar java.utilizar.concurrente.Semáforo;
Semaforecliente de clase pública

Public static void main (String [] args)

Semáforo sem = nuevo semáforo (1);
// Creando dos hilos con el nombre T1 y T2
// El hilo T1 incrementará el recuento
// El hilo T2 disminuirá el recuento
Semaphorethread mt1 = new Semaphorethread (SEM, "T1");
Semaphorethread mt2 = new Semaphorethread (SEM, "T2");
// STAT HIREDS T1 y T2
MT1.comenzar();
mt2.comenzar();
intentar
// Esperando los hilos T1 y T2
MT1.unirse();
mt2.unirse();
capt (interruptedException ex)
Sistema.errar.println ("Excepción:"+ EX.getMessage ());

Sistema.afuera.println ("Count:" + SharedResource.contar);


clase SharedResource
static int count = 0;

Semáforethread.Java
La clase Semaphorethread extiende el hilo

Semáforo _sem;
Cadena _threadName;
Público Semaphorethread (Semaphore SEM, String Thname)

super (gracias);
este._sem = sem;
este._threadName = thname;

@Anular
Public void run ()

si esto.getName ().igual ("t1"))

Sistema.afuera.println ("comenzando" + esto._ThreadName);
intentar

Sistema.afuera.println (esto._ThreadName + "está esperando un permiso.");
// adquiriendo el bloqueo
este._sem.adquirir();
Sistema.afuera.println (esto._ThreadName + "Obtiene un permiso.");
para (int i = 0; i < 5; i++)

SharedResource.contar ++;
Sistema.afuera.println (_threadname + ":" + SharedResource.contar);
Hilo.dormir (20);


captura (interruptedException exc)

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

// Libere el permiso.
Sistema.afuera.println (_threadname + "libera el permiso.");
este._sem.liberar();

else //// ejecutar por hilo t2

Sistema.afuera.println ("iniciar" + _threadName);
intentar

// Primero, obtenga un permiso.
Sistema.afuera.println (esto._ThreadName + "está esperando un permiso.");
este._sem.adquirir();
Sistema.afuera.println (_threadname + "obtiene un permiso.");
para (int i = 0; i < 5; i++)

SharedResource.contar--;
Sistema.afuera.println (_threadname
+ ":" + SharedResource.contar);
Hilo.dormir (20);


captura (interruptedException exc)

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

// Libere el permiso.
Sistema.afuera.println (_threadname + "libera el permiso.");
_sem.liberar();

//correr()
//clase

Ahora en el código anterior, hemos definido tres clases diferentes que son 'Semphoreclient', 'SharedResource', y 'Semaphorethread'. En Semaphoreclient hemos inicializado dos hilos con un permiso. El hilo T1 incrementará el contador cuando se ejecute mientras el hilo T2 lo disminuirá. SharedResource Class es de donde los hilos compartirán el acceso. En la clase Semaphorethread, hemos iniciado el proceso de bloqueo para ambos subprocesos T1 y T2, lo que significa que si alguno de los dos subprocesos bloquea el proceso y comienza a ejecutar, el otro tiene que esperar hasta que se haya lanzado el bloqueo. Ahora, antes de ejecutar el código, debe asegurarse primero que ha instalado la aplicación Java Development Kit (JDK) en su sistema operativo Linux utilizando el siguiente comando en el terminal

$ sudo apt instalación predeterminado-jdk

Ahora, después de su verificación, puede abrir cualquier editor y luego escribir y guardar el código Java dentro de él como se muestra a continuación.

$ nano semáforeclient.Java

El código que hemos escrito dentro del 'Semaforecliente.Java' El archivo se muestra a continuación.

Puede ver la salida del código como se muestra a continuación

La salida muestra que hay dos hilos; En la primera imagen, el hilo T1 se ha ejecutado, y luego una vez que T1 libera el permiso, el hilo T2 comienza a ejecutarse; En la segunda imagen, el hilo T2 se ha ejecutado primero, seguido por el hilo T1. Esto implica que cualquier hilo tuvo la oportunidad primero bloqueará el proceso, requeriendo que el otro hilo espere.

Conclusión

Un semáforo es un objeto Java que se utiliza para controlar el acceso a un recurso compartido y es un método de sincronización de subprocesos que le permite enviar señales a través de los subprocesos para administrar varias tareas al mismo tiempo. Otorga acceso al recurso compartido y, como resultado, un hilo primero debe obtener permiso del semáforo antes de usar los recursos. En este artículo, hemos creado dos hilos A y B con un permiso. Por lo tanto, cualquiera de estos dos hilos comenzará a ejecutar y bloquear el proceso, luego el otro subproceso debe esperar hasta que se libere el proceso.