Java Counting Semaphore mantiene un número específico de pases o permisos, y el subproceso actual debe obtener un permiso para acceder a un recurso compartido. Si un permiso ya está agotado por otros subprocesos, puede esperar hasta que el permiso esté disponible como resultado de la liberación de permisos de varios subprocesos. Esta utilidad de concurrencia puede ser muy útil para implementar un patrón de diseño productor-consumidor o implementar grupos limitados de activos como Thread Pool, DB Connection Pool, etc. La clase java.util.Semaphore es un semáforo de conteo que se inicializa con un número de permisos.
Semaphore proporciona dos métodos principales para obtener permisos y liberar permisos
- adquirir( ): este método adquiere un permiso si hay alguno disponible y lo devuelve inmediatamente, reduciendo el número de permisos disponibles en uno. Si el subproceso actual se interrumpe mientras espera un permiso,se lanza una InterruptedException .
- release() : este método adquiere el número dado de permisos, si están disponibles, y regresa inmediatamente, reduciendo el número de permisos disponibles por la cantidad dada. Si el subproceso actual se interrumpe mientras espera un permiso, se lanza una InterruptedException.
Implementación:
Un semáforo binario se conoce como semáforo de conteo con un permiso porque solo tiene dos permisos estatales disponibles o permisos no disponibles. Para ejecutar la exclusión mutua o la sección crítica donde solo se permite ejecutar un subproceso, se puede usar un semáforo binario. Un subproceso espera adquirir() hasta que Thread permite la liberación dentro de la sección crítica llamando a release() en el semáforo. A continuación se muestra el conteo de semáforos de Java donde se usa el semáforo binario para proporcionar acceso exclusivo compartido a partes esenciales del código
Ejemplo:
Java
// Java Program to illustrate use Counting Semaphore
// in Concurrent Java Application
import java.util.concurrent.Semaphore;
public class SemaphoreTest {
// Initialize the semaphore with the number
// of permits required
// Here only 1 permit is allowed
Semaphore binary = new Semaphore(1);
// Main driver method
public static void main(String args[])
{
final SemaphoreTest test = new SemaphoreTest();
// Thread 1
new Thread() {
// Method that should be executed for thread1
@Override public void run()
{
test.mutualExclusion();
}
}.start();
// Thread 2
new Thread() {
// Method that should be executed for thread2
@Override public void run()
{
test.mutualExclusion();
}
}.start();
}
// Method
private void mutualExclusion()
{
// Try block to check for exceptions
try {
// acquire() acts as an input to semaphore
// to check for available permits
binary.acquire();
// Mutual exclusive region
System.out.println(
Thread.currentThread().getName()
+ " inside mutual exclusive ");
// sleep() method is used to hold thread for
// sometime Parameter is nanoseconds to be
// holded
Thread.sleep(1000);
}
// Catch block to handle the exception
// Handling exception if thread is interrupted
// either before or during the activity
catch (InterruptedException e) {
// Print and display the line number where
// exception occurred
e.printStackTrace();
}
finally {
// release() method acts as output to semaphore
// When thread operation is completed
// release() method increase the permits
// in the semaphore
binary.release();
// Printing the thread name
// using the getName() method
System.out.println(
Thread.currentThread().getName()
+ " outside of mutual exclusive ");
}
}
}
Thread-0 inside mutual exclusive Thread-1 inside mutual exclusive Thread-0 outside of mutual exclusive Thread-1 outside of mutual exclusive
Publicación traducida automáticamente
Artículo escrito por kapilnama1998 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA