Semáforos en Kotlin

Semáforo es un conjunto de permisos. Asumirlo como una caja que tiene las fichas(permisos) para atender(realizar) una tarea. Los subprocesos tienen acceso a Semaphore pero no a esos permisos. Dependiendo del número de permisos, y cuando llega un hilo al semáforo, se da un permiso. Si un Thread llega cuando no hay permisos disponibles, tiene que esperar hasta que se le asigne un permiso. Sólo entonces se puede realizar una tarea.

Básicamente, un semáforo se usa en subprocesos múltiples o en una aplicación de subprocesos múltiples. Puede haber múltiples procesos ejecutándose en una aplicación. El uso de Semaphore es restringir o controlar el acceso a cualquier recurso común por múltiples subprocesos (procesos). El semáforo, por definición, se usa para señalar de una tarea a otra. Permiten una gestión flexible de la fuente.

Visualización del proceso de subprocesos múltiples utilizando un semáforo

1. Subprocesos que llegan a Semaphore para los recursos.
   
2. Semáforo que asigna permisos a los subprocesos y detiene el resto de los subprocesos si no alcanza los permisos. El proceso de asignación de permiso a un subproceso se denomina adquisición .
   
3. Los subprocesos que se ejecutan anteriormente liberan los permisos cuando se completa la tarea. Estos permisos ahora se asignan a los subprocesos detenidos. Este proceso en el que los subprocesos devuelven el permiso se denomina Liberación .
   

El siguiente programa está en Kotlin , un ejemplo en el que se usa un semáforo para ejecutar alguna actividad en un proceso de subprocesos múltiples:

• Al semáforo se le asigna un valor de permiso de 2, lo que significa que solo se pueden ejecutar 2 subprocesos a la vez.
• Los subprocesos declarados en el siguiente código tienen una actividad de suspensión de 10 segundos (10000 milisegundos), lo que significa que cualquiera de los subprocesos adquiere un permiso durante 10 segundos.
• Se declara una función de impresión para imprimir «.» para representar que la actividad del subproceso ha finalizado y se ha liberado el permiso.
• Dado que no hay una prioridad asignada a ninguno de los Subprocesos, se otorgará una NORM_PRIORITY (Prioridad predeterminada = 5) a todos los Subprocesos y Preferencia al Subproceso que llegue primero.

import java.util.concurrent.Semaphore
  
val s = Semaphore(2)
  
val t1 = Thread(Runnable 
{
    s.acquireUninterruptibly()
    print("t1")
    Thread.sleep(10000)
    print(".")
    s.release()
})
  
val t2 = Thread(Runnable 
{
    s.acquireUninterruptibly()
    print("t2")
    Thread.sleep(10000)
    print(".")
    s.release()
})
  
val t3 = Thread(Runnable 
{
    s.acquireUninterruptibly()
    print("t3")
    Thread.sleep(10000)
    print(".")
    s.release()
})
  
val t4 = Thread(Runnable 
{
    s.acquireUninterruptibly()
    print("t4")
    Thread.sleep(10000)
    print(".")
    s.release()
})
  
  
t1.start()
t2.start()
t3.start()
t4.start()

Producción:

t1t2..t3t4..

Aquí 2 puntos, es decir, en la salida «..» representa 10 segundos de espera (Thread.sleep) entre la adquisición del permiso y la liberación del permiso.

Nota : Es posible establecer la prioridad de los subprocesos. En tal caso, los Threads están en orden de Prioridad y así mismo, se les asignan Permisos. Se pueden declarar múltiples semáforos dependiendo de la cantidad de recursos requeridos por el proceso.