Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Semaphore-Klasse

 

Veröffentlicht: August 2016

Schränkt die Anzahl von Threads ein, die gleichzeitig auf eine Ressource oder einen Pool von Ressourcen zugreifen können.

Namespace:   System.Threading
Assembly:  System (in System.dll)

System.Object
  System.MarshalByRefObject
    System.Threading.WaitHandle
      System.Threading.Semaphore

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public sealed class Semaphore : WaitHandle

NameBeschreibung
System_CAPS_pubmethodSemaphore(Int32, Int32)

Initialisiert eine neue Instanz der Semaphore-Klasse und gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen an.

System_CAPS_pubmethodSemaphore(Int32, Int32, String)

Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an.

System_CAPS_pubmethodSemaphore(Int32, Int32, String, Boolean)

Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen sowie optional den Namen eines Systemsemaphorobjekts an, gibt eine Variable an, die einen Wert empfängt, der angibt, ob ein neues Systemsemaphor erstellt wurde.

System_CAPS_pubmethodSemaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)

Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die ursprüngliche Anzahl von Einträgen und die maximale Anzahl von gleichzeitigen Einträgen an, gibt optional den Namen eines Systemsemaphorobjekts an, gibt eine Variable an, die einen Wert empfängt, der angibt, ob ein neues Systemsemaphor erstellt wurde, und gibt die Sicherheitszugriffssteuerung für das Systemsemaphor an.

NameBeschreibung
System_CAPS_pubpropertyHandle

Veraltet.Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.(Geerbt von „WaitHandle“.)

System_CAPS_pubpropertySafeWaitHandle

Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest.(Geerbt von „WaitHandle“.)

NameBeschreibung
System_CAPS_pubmethodClose()

Gibt alle von der aktuellen WaitHandle-Klasse reservierten Ressourcen frei.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodCreateObjRef(Type)

Erstellt ein Objekt, das alle relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodDispose()

Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_pubmethodGetAccessControl()

Ruft die Zugriffssteuerungssicherheit für ein benanntes Systemsemaphor ab.

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetLifetimeService()

Ruft die aktuellen Service-Objekt, das die Lebensdauerrichtlinien für diese Instanz steuert.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodInitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinien für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String)

Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist.

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String, SemaphoreRights)

Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.

System_CAPS_pubmethodRelease()

Beendet das Semaphor und gibt die vorherige Anzahl zurück.

System_CAPS_pubmethodRelease(Int32)

Gibt das Semaphor eine festgelegte Anzahl von Malen frei und gibt die vorherige Anzahl zurück.

System_CAPS_pubmethodSetAccessControl(SemaphoreSecurity)

Legt die Zugriffssteuerungssicherheit für ein benanntes Systemsemaphor fest.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, Semaphore)

Öffnet das angegebene benannte Semaphor, wenn es bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, SemaphoreRights, Semaphore)

Öffnet das angegebene benannte Semaphor, wenn es bereits mit dem gewünschten Sicherheitszugriff vorhanden ist und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.

System_CAPS_pubmethodWaitOne()

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodWaitOne(Int32)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls in Millisekunden verwendet wird.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodWaitOne(Int32, Boolean)

Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodWaitOne(TimeSpan)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird.(Geerbt von „WaitHandle“.)

System_CAPS_pubmethodWaitOne(TimeSpan, Boolean)

Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet und angegeben wird, ob die Synchronisierungsdomäne vor dem Wartevorgang verlassen werden soll.(Geerbt von „WaitHandle“.)

NameBeschreibung
System_CAPS_pubmethodGetSafeWaitHandle()

Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait-Handle ab.(Definiert durch WaitHandleExtensions.)

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

Stellt ein sicheres Handle für ein systemeigenes Betriebssystem-Wait-Handle ein.(Definiert durch WaitHandleExtensions.)

Verwenden der Semaphore Klasse zum Steuern des Zugriffs auf einen Pool von Ressourcen. Threads das Semaphor durch Aufrufen der WaitOne -Methode, die erbt die WaitHandle Klasse, und geben das Semaphor durch Aufrufen der Release Methode.

Die Anzahl die auf einem Semaphore wird jedes Mal ein Thread das Semaphor gibt, und inkrementiert, wenn ein Thread das Semaphor freigibt verringert. Wenn die Anzahl Null ist, blockiert nachfolgende Anforderungen, bis andere Threads das Semaphor freigeben. Wenn alle Threads das Semaphor freigegeben haben, wird die Anzahl die den maximalen Wert angegeben, wenn das Semaphor erstellt wurde.

Es gibt keine festgelegte Reihenfolge, z. B. FIFO oder LIFO, in dem blockierte Threads das Semaphor.

Ein Thread kann das Semaphor mehrfach durch Aufrufen der WaitOne -Methode wiederholt. Um einige oder alle dieser Einträge freizugeben, kann der Thread die parameterlose Aufrufen Release() mehrmals, oder sie aufrufen können, eine Überladung der Release(Int32) eine Überladung, die die Anzahl der freizugebenden Einträge angibt.

Die Semaphore -Klasse erzwingt keine Threadidentität für Aufrufe von WaitOne oder Release. Es ist der Programmierer dafür verantwortlich sicherzustellen, dass Threads das Semaphor nicht zu oft freigeben. Angenommen, ein Semaphor hat einen maximalen Zähler von zwei und Thread A sowie Thread B wechseln beide in das Semaphor. Wenn ein Programmierfehler in Thread B führt Aufrufen Release sind beide Aufrufe erfolgreich. Der Zähler des Semaphors ist voll, und wenn thread A ruft schließlich Release, ein SemaphoreFullException ausgelöst.

Gibt zwei Arten von Semaphoren: lokale Semaphore und benanntes Semaphore. Wenn Sie erstellen ein Semaphore -Objekt mithilfe eines Konstruktors, der einen Namen akzeptiert ein Semaphor Betriebssystem mit dem Namen zugeordnet ist. Benannte Semaphoren sind im gesamten Betriebssystem sichtbar und können verwendet werden, um die Aktivitäten von Prozessen zu synchronisieren. Sie können mehrere erstellen Semaphore Objekte, die die gleiche darstellen benannte Systemsemaphor, und Sie können die OpenExisting Methode zum Öffnen einer vorhandenen benannte Systemsemaphor.

Ein lokales Semaphor ist nur innerhalb des Prozesses vorhanden. Hiermit können von jedem Thread im Prozess, der einen Verweis auf die lokale Semaphore Objekt. Jedes Semaphore Objekt ist ein separates lokales Semaphor.

Im folgenden Codebeispiel wird ein Semaphor mit einem maximalen Zähler von drei und einem anfänglichen Zähler von 0 (null) erstellt. Das Beispiel beginnt fünf Threads das Semaphor warten zu blockieren. Der Hauptthread verwendet die Release(Int32) erhöht den Zähler des Semaphors auf seinen Maximalwert, sodass drei Threads in das Semaphor eine Überladung. Jeder Thread verwendet die Thread.Sleep Methode für eine Sekunde warten, Arbeit und ruft dann simuliert die Release() Überladung-Methode verwendet, um das Semaphor freizugeben. Jedes Mal, wenn das Semaphor freigegeben ist, wird die vorherige Semaphorenanzahl angezeigt. Nachrichten nachverfolgen Semaphore verwenden. Das simulierte Intervall wird für jeden Thread, um die Ausgabe leichter lesbar zu machen geringfügig erhöht.

using System;
using System.Threading;

public class Example
{
    // A semaphore that simulates a limited resource pool.
    //
    private static Semaphore _pool;

    // A padding interval to make the output more orderly.
    private static int _padding;

    public static void Main()
    {
        // Create a semaphore that can satisfy up to three
        // concurrent requests. Use an initial count of zero,
        // so that the entire semaphore count is initially
        // owned by the main program thread.
        //
        _pool = new Semaphore(0, 3);

        // Create and start five numbered threads. 
        //
        for(int i = 1; i <= 5; i++)
        {
            Thread t = new Thread(new ParameterizedThreadStart(Worker));

            // Start the thread, passing the number.
            //
            t.Start(i);
        }

        // Wait for half a second, to allow all the
        // threads to start and to block on the semaphore.
        //
        Thread.Sleep(500);

        // The main thread starts out holding the entire
        // semaphore count. Calling Release(3) brings the 
        // semaphore count back to its maximum value, and
        // allows the waiting threads to enter the semaphore,
        // up to three at a time.
        //
        Console.WriteLine("Main thread calls Release(3).");
        _pool.Release(3);

        Console.WriteLine("Main thread exits.");
    }

    private static void Worker(object num)
    {
        // Each worker thread begins by requesting the
        // semaphore.
        Console.WriteLine("Thread {0} begins " +
            "and waits for the semaphore.", num);
        _pool.WaitOne();

        // A padding interval to make the output more orderly.
        int padding = Interlocked.Add(ref _padding, 100);

        Console.WriteLine("Thread {0} enters the semaphore.", num);

        // The thread's "work" consists of sleeping for 
        // about a second. Each thread "works" a little 
        // longer, just to make the output more orderly.
        //
        Thread.Sleep(1000 + padding);

        Console.WriteLine("Thread {0} releases the semaphore.", num);
        Console.WriteLine("Thread {0} previous semaphore count: {1}",
            num, _pool.Release());
    }
}

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Windows Phone Silverlight
Verfügbar seit 8.0
Windows Phone
Verfügbar seit 8.1

Dieser Typ ist threadsicher.

Zurück zum Anfang
Anzeigen: