Semaphore Klasse

Referenz

Definition

Namespace:: Java.Util.Concurrent

Assembly:: Mono.Android.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Ein Zählsemaphor.

[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

Vererbung: Object

Object
Semaphore

Attribute: RegisterAttribute

Implementiert: IJavaObject IJavaPeerable ISerializable IDisposable

Hinweise

Ein Zählsemaphor. Konzeptionell behält ein Semaphor eine Reihe von Genehmigungen bei. Jeder #acquire blockiert bei Bedarf, bis eine Genehmigung vorliegt, und nimmt sie dann ein. Jede #release fügt eine Genehmigung hinzu und gibt möglicherweise einen blockierenden Acquirer frei. Es werden jedoch keine tatsächlichen Genehmigungsobjekte verwendet; die Semaphore nur die Anzahl der verfügbaren Zahlen hält und entsprechend handelt.

Semaphore werden häufig verwendet, um die Anzahl von Threads einzuschränken, als auf einige (physische oder logische) Ressourcen zugreifen können. Hier sehen Sie beispielsweise eine Klasse, die einen Semaphor verwendet, um den Zugriff auf einen Pool von Elementen zu steuern:

{@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;
              }
            }}

Vor dem Abrufen eines Elements muss jeder Thread eine Genehmigung vom Semaphor erwerben, um sicherzustellen, dass ein Element zur Verwendung verfügbar ist. Wenn der Thread mit dem Element fertig ist, wird es an den Pool zurückgegeben, und eine Genehmigung wird an den Semaphor zurückgegeben, sodass ein anderer Thread dieses Element abrufen kann. Beachten Sie, dass beim #acquire Aufrufen keine Synchronisierungssperre gilt, da dadurch verhindert würde, dass ein Element an den Pool zurückgegeben wird. Das Semaphor kapselt die Synchronisierung, die erforderlich ist, um den Zugriff auf den Pool zu beschränken, getrennt von allen Synchronisierungen, die zur Aufrechterhaltung der Konsistenz des Pools selbst erforderlich sind.

Ein Semaphor, das zu einem initialisiert wird und so verwendet wird, dass nur höchstens eine Genehmigung verfügbar ist, kann als gegenseitige Ausschlusssperre dienen. Dies wird häufiger als binary semaphore bezeichnet, da es nur über zwei Zustände verfügt: eine Genehmigung verfügbar oder null Genehmigungen verfügbar. Bei dieser Verwendung hat der binäre Semaphor (im Gegensatz zu vielen java.util.concurrent.locks.Lock Implementierungen) die -Eigenschaft, dass der " lock" kann von einem anderen Thread als dem Besitzer freigegeben werden (da Semaphore keinen Besitzbegriff haben). Dies kann in einigen speziellen Kontexten nützlich sein, z. B. bei der Deadlockwiederherstellung.

Der Konstruktor für diese Klasse akzeptiert optional einen fairness</em-Parameter> . Wenn der Wert false festgelegt ist, gibt diese Klasse keine Garantien für die Reihenfolge ab, in der Threads Genehmigungen erhalten. Insbesondere <ist em>barging zulässig, d. h., einem Thread, der aufgerufen #acquire wird, kann eine Genehmigung vor einem Thread zugewiesen werden, der gewartet hat - logischerweise platziert sich der neue Thread an der Spitze der Warteschleife. Wenn fairness true festgelegt ist, garantiert das Semaphor, dass Fäden, die eine der #acquire() acquire Methoden aufrufen, ausgewählt werden, um Genehmigungen in der Reihenfolge zu erhalten, in der ihr Aufruf dieser Methoden verarbeitet wurde (first-in-first-out; FIFO). Beachten Sie, dass die FIFO-Reihenfolge notwendigerweise für bestimmte interne Ausführungspunkte innerhalb dieser Methoden gilt. Daher ist es möglich, dass ein Thread vor einem anderen aufgerufen acquire wird, aber den Reihenfolgespunkt nach dem anderen erreicht, und auf ähnliche Weise, wenn er von der -Methode zurückgegeben wird. Beachten Sie auch, dass die Methoden ohne Zeit #tryAcquire() tryAcquire die Fairnesseinstellung nicht berücksichtigen, aber alle verfügbaren Genehmigungen annehmen.

Im Allgemeinen sollten Semaphore, die zum Steuern des Ressourcenzugriffs verwendet werden, als fair initialisiert werden, um sicherzustellen, dass kein Thread vom Zugriff auf eine Ressource ausgehungert wird. Bei der Verwendung von Semaphoren für andere Arten der Synchronisierungssteuerung überwiegen häufig die Durchsatzvorteile einer nicht fairen Reihenfolge.

Diese Klasse bietet auch bequeme Methoden für #acquire(int) acquire und #release(int) release mehrere Genehmigungen gleichzeitig. Diese Methoden sind im Allgemeinen effizienter und effektiver als Schleifen. Sie legen jedoch keine Präferenzreihenfolge fest. Wenn beispielsweise Thread A aufruft s.acquire(3und Thread B aufruft und zwei Genehmigungen s.acquire(2)verfügbar werden, gibt es keine Garantie dafür, dass Thread B sie erhält, es sei denn, sein Abruf kam zuerst und Semaphore befindet sich im fairen s Modus.

Speicherkonsistenzeffekte: Aktionen in einem Thread vor dem Aufrufen einer "Release"-Methode wie release()happen-before</i-Aktionen> nach einer erfolgreichen "acquire"-Methode, z acquire() . B. in einem anderen Thread.

Hinzugefügt in 1.5.

Java-Dokumentation für java.util.concurrent.Semaphore.

Teile dieser Seite sind Änderungen, die auf Arbeiten basieren, die vom Android Open Source Project erstellt und freigegeben wurden und gemäß den In Attribution License beschriebenen Begriffen verwendet werden.

Konstruktoren

Semaphore(Int32)	Erstellt eine `Semaphore` mit der angegebenen Anzahl von Genehmigungen und nicht fairen Fairnesseinstellungen.
Semaphore(Int32, Boolean)	Erstellt eine `Semaphore` mit der angegebenen Anzahl von Genehmigungen und der angegebenen Fairnesseinstellung.
Semaphore(IntPtr, JniHandleOwnership)	Ein Konstruktor, der beim Erstellen verwalteter Darstellungen von JNI-Objekten verwendet wird; wird von der Runtime aufgerufen.

Eigenschaften

Class	Gibt die Laufzeitklasse dieses `Object`zurück. (Geerbt von Object)
Handle	Das Handle für die zugrunde liegende Android-instance. (Geerbt von Object)
HasQueuedThreads	Fragt ab, ob Threads auf den Abruf warten.
IsFair	Gibt zurück `true` , wenn für diesen Semaphor die Fairness true festgelegt ist.
JniIdentityHashCode	Ein Zählsemaphor. (Geerbt von Object)
JniPeerMembers	Ein Zählsemaphor.
PeerReference	Ein Zählsemaphor. (Geerbt von Object)
QueuedThreads	Gibt eine Auflistung zurück, die Threads enthält, die möglicherweise auf den Abruf warten.
QueueLength	Gibt eine Schätzung der Anzahl der Threads zurück, die auf den Abruf warten.
ThresholdClass	Diese API unterstützt die Mono für Android-Infrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code vorgesehen.
ThresholdType	Diese API unterstützt die Mono für Android-Infrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code vorgesehen.

Methoden

Acquire()	Ruft eine Genehmigung von diesem Semaphor ab und blockiert, bis ein Thread verfügbar ist oder der Thread unterbrochen wird.
Acquire(Int32)	Ruft die angegebene Anzahl von Genehmigungen von diesem Semaphor ab und blockiert, bis alle verfügbar sind, oder der Thread wird von Thread#interrupt unterbrochen.
AcquireUninterruptibly()	Erwirbt eine Genehmigung von diesem Semaphor und blockiert, bis eine verfügbar ist.
AcquireUninterruptibly(Int32)	Ruft die angegebene Anzahl von Genehmigungen von diesem Semaphor ab und blockiert, bis alle verfügbar sind.
AvailablePermits()	Gibt die aktuelle Anzahl der in diesem Semaphor verfügbaren Genehmigungen zurück.
Clone()	Erstellt und gibt eine Kopie dieses Objekts zurück. (Geerbt von Object)
Dispose()	Ein Zählsemaphor. (Geerbt von Object)
Dispose(Boolean)	Ein Zählsemaphor. (Geerbt von Object)
DrainPermits()	Erwirbt und gibt alle sofort verfügbaren Genehmigungen zurück, oder wenn negative Genehmigungen verfügbar sind, gibt sie frei.
Equals(Object)	Gibt an, ob ein anderes Objekt "gleich" diesem objekt ist. (Geerbt von Object)
GetHashCode()	Gibt einen Hashcodewert für das Objekt zurück. (Geerbt von Object)
JavaFinalize()	Wird vom Garbage Collector für ein Objekt aufgerufen, wenn die Garbage Collection feststellt, dass keine Verweise mehr auf das Objekt vorhanden sind. (Geerbt von Object)
Notify()	Aktiviert einen einzelnen Thread, der auf den Monitor dieses Objekts wartet. (Geerbt von Object)
NotifyAll()	Aktiviert alle Threads, die auf den Monitor dieses Objekts warten. (Geerbt von Object)
ReducePermits(Int32)	Verkleinert die Anzahl der verfügbaren Genehmigungen um die angegebene Reduzierung.
Release()	Gibt eine Genehmigung frei und gibt sie an den Semaphor zurück.
Release(Int32)	Gibt die angegebene Anzahl von Genehmigungen frei und gibt sie an den Semaphor zurück.
SetHandle(IntPtr, JniHandleOwnership)	Legt die Handle-Eigenschaft fest. (Geerbt von Object)
ToArray<T>()	Ein Zählsemaphor. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolgendarstellung des Objekts zurück. (Geerbt von Object)
TryAcquire()	Erwirbt von diesem Semaphor nur dann eine Genehmigung, wenn eine zum Zeitpunkt des Aufrufs verfügbar ist.
TryAcquire(Int32)	Erwirbt die angegebene Anzahl von Genehmigungen von diesem Semaphor nur, wenn alle zum Zeitpunkt des Aufrufs verfügbar sind.
TryAcquire(Int32, Int64, TimeUnit)	Ruft die angegebene Anzahl von Genehmigungen von diesem Semaphor ab, wenn alle innerhalb der angegebenen Wartezeit verfügbar sind und der aktuelle Thread nicht unterbrochen wurde.
TryAcquire(Int64, TimeUnit)	Ruft eine Genehmigung von diesem Semaphor ab, wenn eine innerhalb der angegebenen Wartezeit verfügbar ist und der aktuelle Thread nicht unterbrochen wurde.
UnregisterFromRuntime()	Ein Zählsemaphor. (Geerbt von Object)
Wait()	Bewirkt, dass der aktuelle Thread wartet, bis er aktiviert ist, in der Regel durch <>Benachrichtigung</em> oder <em>interrupted</em>. (Geerbt von Object)
Wait(Int64)	Bewirkt, dass der aktuelle Thread wartet, bis er aktiviert ist, in der Regel durch>< Benachrichtigung</em> oder <em>interrupted</em>, oder bis eine bestimmte Menge an Echtzeit verstrichen ist. (Geerbt von Object)
Wait(Int64, Int32)	Bewirkt, dass der aktuelle Thread wartet, bis er aktiviert ist, in der Regel durch>< Benachrichtigung</em> oder <em>interrupted</em>, oder bis eine bestimmte Menge an Echtzeit verstrichen ist. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IJavaPeerable.Disposed()	Ein Zählsemaphor. (Geerbt von Object)
IJavaPeerable.DisposeUnlessReferenced()	Ein Zählsemaphor. (Geerbt von Object)
IJavaPeerable.Finalized()	Ein Zählsemaphor. (Geerbt von Object)
IJavaPeerable.JniManagedPeerState	Ein Zählsemaphor. (Geerbt von Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Ein Zählsemaphor. (Geerbt von Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Ein Zählsemaphor. (Geerbt von Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Ein Zählsemaphor. (Geerbt von Object)

Erweiterungsmethoden

JavaCast<TResult>(IJavaObject)	Führt eine Typkonvertierung mit Überprüfung der Android-Laufzeit aus.
JavaCast<TResult>(IJavaObject)	Ein Zählsemaphor.
GetJniTypeName(IJavaPeerable)	Ein Zählsemaphor.

Gilt für: