Semaphore Clase

Referencia

Definición

Espacio de nombres:: Java.Util.Concurrent

Ensamblado:: Mono.Android.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Semáforo de recuento.

[Android.Runtime.Register("java/util/concurrent/Semaphore", DoNotGenerateAcw=true)]
public class Semaphore : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable

[<Android.Runtime.Register("java/util/concurrent/Semaphore", DoNotGenerateAcw=true)>]
type Semaphore = class
    inherit Object
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Herencia: Object

Object
Semaphore

Atributos: RegisterAttribute

Implementaciones: IJavaObject IJavaPeerable ISerializable IDisposable

Comentarios

Semáforo de recuento. Conceptualmente, un semáforo mantiene un conjunto de permisos. Cada #acquire uno se bloquea si es necesario hasta que haya un permiso disponible y, a continuación, lo toma. Cada #release uno agrega un permiso, liberando potencialmente un adquiridor de bloqueo. Sin embargo, no se utilizan objetos de permiso reales; simplemente Semaphore mantiene un recuento del número disponible y actúa en consecuencia.

Los semáforos se usan a menudo para restringir el número de subprocesos que pueden acceder a algunos recursos (físicos o lógicos). Por ejemplo, esta es una clase que usa un semáforo para controlar el acceso a un grupo de elementos:

{@code
            class Pool {
              private static final int MAX_AVAILABLE = 100;
              private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

              public Object getItem() throws InterruptedException {
                available.acquire();
                return getNextAvailableItem();
              }

              public void putItem(Object x) {
                if (markAsUnused(x))
                  available.release();
              }

              // Not a particularly efficient data structure; just for demo

              protected Object[] items = ...; // whatever kinds of items being managed
              protected boolean[] used = new boolean[MAX_AVAILABLE];

              protected synchronized Object getNextAvailableItem() {
                for (int i = 0; i < MAX_AVAILABLE; ++i) {
                  if (!used[i]) {
                    used[i] = true;
                    return items[i];
                  }
                }
                return null; // not reached
              }

              protected synchronized boolean markAsUnused(Object item) {
                for (int i = 0; i < MAX_AVAILABLE; ++i) {
                  if (item == items[i]) {
                    if (used[i]) {
                      used[i] = false;
                      return true;
                    } else
                      return false;
                  }
                }
                return false;
              }
            }}

Antes de obtener un elemento, cada subproceso debe adquirir un permiso del semáforo, lo que garantiza que un elemento está disponible para su uso. Cuando el subproceso ha terminado con el elemento, se devuelve al grupo y se devuelve un permiso al semáforo, lo que permite que otro subproceso adquiera ese elemento. Tenga en cuenta que no se mantiene ningún bloqueo de sincronización cuando #acquire se llama a , ya que impediría que se devuelva un elemento al grupo. El semáforo encapsula la sincronización necesaria para restringir el acceso al grupo, independientemente de cualquier sincronización necesaria para mantener la coherencia del propio grupo.

Un semáforo inicializado en uno, que se usa para que solo tenga al máximo un permiso disponible, puede servir como bloqueo de exclusión mutua. Esto se conoce normalmente como <semáforo<> binario em>, ya que solo tiene dos estados: un permiso disponible o cero permisos disponibles. Cuando se usa de esta manera, el semáforo binario tiene la propiedad (a diferencia de muchas java.util.concurrent.locks.Lock implementaciones), que el &cita; bloquear&comillas; puede ser liberado por un subproceso distinto del propietario (ya que los semáforos no tienen ninguna noción de propiedad). Esto puede ser útil en algunos contextos especializados, como la recuperación de interbloqueos.

El constructor de esta clase acepta opcionalmente un <parámetro em>fairness</em> . Cuando se establece false, esta clase no garantiza el orden en que los subprocesos adquieren permisos. En concreto, <se permite el>uso de barging</em> , es decir, se puede asignar un #acquire permiso por delante de un subproceso que ha estado esperando; lógicamente, el nuevo subproceso se coloca en la cabeza de la cola de subprocesos en espera. Cuando se establece la equidad, el semáforo garantiza que los subprocesos que invocan cualquiera de los #acquire() acquire métodos se seleccionan para obtener permisos en el orden en que se procesó su invocación de esos métodos (primero en salir; FIFO). Tenga en cuenta que la ordenación de FIFO se aplica necesariamente a puntos internos específicos de ejecución dentro de estos métodos. Por lo tanto, es posible que un subproceso invoque acquire antes que otro, pero llegue al punto de ordenación después del otro, y de forma similar al retorno del método . Tenga en cuenta también que los métodos notimes #tryAcquire() tryAcquire no respetan la configuración de equidad, pero tomará los permisos disponibles.

Por lo general, los semáforos que se usan para controlar el acceso a los recursos deben inicializarse como justos, para asegurarse de que no haya ningún subproceso agotado para acceder a un recurso. Al usar semáforos para otros tipos de control de sincronización, las ventajas de rendimiento de la ordenación no justa suelen superar las consideraciones de equidad.

Esta clase también proporciona métodos útiles para #acquire(int) acquire y #release(int) release varios permisos a la vez. Por lo general, estos métodos son más eficaces y eficaces que los bucles. Sin embargo, no establecen ningún orden de preferencia. Por ejemplo, si el subproceso A invoca ) y el subproceso s.acquire(2)B invoca , y dos permisos están disponibles, no hay ninguna garantía de que el subproceso s.acquire(3B los obtenga a menos que su adquisición llegue primero y semaphore s esté en modo justo.

Efectos de coherencia de la memoria: acciones en un subproceso antes de llamar a un método "release", como release()<las acciones de i>happen-before</i> después de un método "acquire" correcto, como acquire() en otro subproceso.

Agregado en 1.5.

Documentación de Java para java.util.concurrent.Semaphore.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el proyecto de código Project y que se usan según los términos Creative Commons 2.5 Attribution License.

Constructores

Semaphore(Int32)	Crea un `Semaphore` objeto con el número dado de permisos y un valor de equidad no justo.
Semaphore(Int32, Boolean)	Crea un `Semaphore` objeto con el número especificado de permisos y la configuración de equidad dada.
Semaphore(IntPtr, JniHandleOwnership)	Constructor utilizado al crear representaciones administradas de objetos JNI; llamado por el tiempo de ejecución.

Propiedades

Class	Devuelve la clase en tiempo de ejecución de este `Object`objeto . (Heredado de Object)
Handle	Identificador de la instancia de Android subyacente. (Heredado de Object)
HasQueuedThreads	Consulta si algún subproceso está esperando adquirir.
IsFair	Devuelve `true` si este semáforo tiene la equidad establecida en true.
JniIdentityHashCode	Semáforo de recuento. (Heredado de Object)
JniPeerMembers	Semáforo de recuento.
PeerReference	Semáforo de recuento. (Heredado de Object)
QueuedThreads	Devuelve una colección que contiene subprocesos que pueden estar esperando adquirir.
QueueLength	Devuelve una estimación del número de subprocesos que esperan adquirir.
ThresholdClass	Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código.
ThresholdType	Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código.

Métodos

Acquire()	Adquiere un permiso de este semáforo, bloqueando hasta que uno esté disponible o el subproceso es Thread#interrupt interrumpida.
Acquire(Int32)	Adquiere el número especificado de permisos de este semáforo, el bloqueo hasta que todos están disponibles o el subproceso es Thread#interrupt interrumpida.
AcquireUninterruptibly()	Adquiere un permiso de este semáforo, bloqueando hasta que uno esté disponible.
AcquireUninterruptibly(Int32)	Adquiere el número dado de permisos de este semáforo, bloqueando hasta que todos estén disponibles.
AvailablePermits()	Devuelve el número actual de permisos disponibles en este semáforo.
Clone()	Crea y devuelve una copia de este objeto. (Heredado de Object)
Dispose()	Semáforo de recuento. (Heredado de Object)
Dispose(Boolean)	Semáforo de recuento. (Heredado de Object)
DrainPermits()	Adquiere y devuelve todos los permisos que están disponibles inmediatamente, o si los permisos negativos están disponibles, los libera.
Equals(Object)	Indica si algún otro objeto es "igual a" este. (Heredado de Object)
GetHashCode()	Devuelve un valor de código hash del objeto. (Heredado de Object)
JavaFinalize()	Lo llama el recolector de elementos no utilizados en un objeto cuando la recolección de elementos no utilizados determina que no hay más referencias al objeto . (Heredado de Object)
Notify()	Activa un único subproceso que está esperando en el monitor de este objeto. (Heredado de Object)
NotifyAll()	Activa todos los subprocesos que están esperando en el monitor de este objeto. (Heredado de Object)
ReducePermits(Int32)	Reduce el número de permisos disponibles por la reducción indicada.
Release()	Libera un permiso y lo devuelve al semáforo.
Release(Int32)	Libera el número especificado de permisos, devolviéndolos al semáforo.
SetHandle(IntPtr, JniHandleOwnership)	Establece la propiedad Handle. (Heredado de Object)
ToArray<T>()	Semáforo de recuento. (Heredado de Object)
ToString()	Devuelve una representación de cadena del objeto. (Heredado de Object)
TryAcquire()	Adquiere un permiso de este semáforo, solo si hay uno disponible en el momento de la invocación.
TryAcquire(Int32)	Adquiere el número dado de permisos de este semáforo, solo si todos están disponibles en el momento de la invocación.
TryAcquire(Int32, Int64, TimeUnit)	Adquiere el número especificado de permisos de este semáforo, si todos están disponibles en el tiempo de espera especificado y el subproceso actual no se ha interrumpido la interrupción de Thread#interrupt.
TryAcquire(Int64, TimeUnit)	Adquiere un permiso de este semáforo, si uno está disponible en el tiempo de espera especificado y el subproceso actual no se ha interrumpido la interrupción de Thread#interrupt.
UnregisterFromRuntime()	Semáforo de recuento. (Heredado de Object)
Wait()	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser em notificado/em> o <em>interrumpido</em>.<>< (Heredado de Object)
Wait(Int64)	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object)
Wait(Int64, Int32)	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object)

Implementaciones de interfaz explícitas

IJavaPeerable.Disposed()	Semáforo de recuento. (Heredado de Object)
IJavaPeerable.DisposeUnlessReferenced()	Semáforo de recuento. (Heredado de Object)
IJavaPeerable.Finalized()	Semáforo de recuento. (Heredado de Object)
IJavaPeerable.JniManagedPeerState	Semáforo de recuento. (Heredado de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Semáforo de recuento. (Heredado de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Semáforo de recuento. (Heredado de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Semáforo de recuento. (Heredado de Object)

Métodos de extensión

JavaCast<TResult>(IJavaObject)	Realiza una conversión de tipos comprobados en tiempo de ejecución de Android.
JavaCast<TResult>(IJavaObject)	Semáforo de recuento.
GetJniTypeName(IJavaPeerable)	Semáforo de recuento.

Se aplica a