Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Semaphore-Klasse

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)

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

Der Semaphore-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSemaphore(Int32, Int32)Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die maximale Anzahl gleichzeitiger Einträge an und reserviert optional einige Einträge.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSemaphore(Int32, Int32, String)Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die maximale Anzahl gleichzeitiger Einträge an, reserviert optional einige Einträge für den aufrufenden Thread und gibt optional den Namen eines Systemsemaphorobjekts an.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSemaphore(Int32, Int32, String, Boolean)Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die maximale Anzahl gleichzeitiger Einträge an, reserviert optional einige Einträge für den aufrufenden Thread, gibt optional den Namen eines Systemsemaphorobjekts an und gibt eine Variable an, die einen Wert empfängt, der angibt, ob ein neues Systemsemaphor erstellt wurde.
Öffentliche MethodeSemaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)Initialisiert eine neue Instanz der Semaphore-Klasse, gibt die maximale Anzahl gleichzeitiger Einträge an, reserviert optional einige Einträge für den aufrufenden Thread, 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.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftHandle Veraltet. Ruft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Von WaitHandle geerbt.)
Öffentliche EigenschaftSafeWaitHandleRuft das systemeigene Betriebssystemhandle auf oder legt dieses fest. (Von WaitHandle geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeCloseGibt beim Überschreiben in einer abgeleiteten Klasse alle für das aktuelle WaitHandle reservierten Ressourcen frei. (Von WaitHandle geerbt.)
Öffentliche MethodeCreateObjRefErstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDispose()Gibt alle von der aktuellen Instanz der WaitHandle-Klasse verwendeten Ressourcen frei. (Von WaitHandle geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Öffentliche MethodeGetAccessControlRuft die Zugriffssteuerungssicherheit für ein benanntes Systemsemaphor ab.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeGetLifetimeServiceRuft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeInitializeLifetimeServiceRuft ein Lebensdauerdienstobjekt ab, mit dem die Lebensdauerrichtlinien für diese Instanz gesteuert werden können. (Von MarshalByRefObject geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsOpenExisting(String)Öffnet das angegebene benannte Semaphor aufgenommen, wenn sie bereits vorhanden ist.
Öffentliche MethodeStatischer MemberOpenExisting(String, SemaphoreRights)Öffnet das angegebene benannte Semaphor aufgenommen, wenn sie bereits vorhanden ist, mit dem gewünschten Sicherheitszugriff.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRelease()Beendet das Semaphor und gibt die vorherige Anzahl zurück.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRelease(Int32)Gibt das Semaphor eine festgelegte Anzahl von Malen frei und gibt den vorherigen Zähler zurück.
Öffentliche MethodeSetAccessControlLegt die Zugriffssteuerungssicherheit für ein benanntes Systemsemaphor fest.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt in .NET für Windows Store-AppsTryOpenExisting(String, Semaphore)Öffnet das angegebene benannte Semaphor aufgenommen, wenn sie bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.
Öffentliche MethodeStatischer MemberTryOpenExisting(String, SemaphoreRights, Semaphore)Öffnet das angegebene benannte Semaphor, wenn es bereits mit den gewünschten Sicherheitszugriff vorhanden ist und einen Wert zurückgibt, der angibt, ob der Vorgang erfolgreich war.
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsWaitOne()Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt. (Von WaitHandle geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsWaitOne(Int32)Blockiert den aktuellen Thread, bis das aktuelle WaitHandle ein Signal empfängt, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Zeitintervalls verwendet wird. (Von WaitHandle geerbt.)
Öffentliche MethodeUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsWaitOne(TimeSpan)Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei eine TimeSpan zum Angeben des Zeitintervalls verwendet wird. (Von WaitHandle geerbt.)
Öffentliche MethodeWaitOne(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. (Von WaitHandle geerbt.)
Öffentliche MethodeWaitOne(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. (Von WaitHandle geerbt.)
Zum Seitenanfang

Steuern Sie mithilfe der Semaphore-Klasse den Zugriff auf einen Pool von Ressourcen. Threads wechseln in das Semaphor, indem sie die WaitOne-Methode aufrufen, die von der WaitHandle-Klasse geerbt wird, und geben das Semaphor durch Aufrufen der Release-Methode frei.

Der Zähler für ein Semaphor verringert sich jedes Mal, wenn dem Semaphor ein Thread hinzugefügt wird, und er erhöht sich, wenn ein Thread das Semaphor freigibt. Wenn der Zähler 0 (null) ist, werden nachfolgende Anforderungen blockiert, bis andere Threads das Semaphor freigeben. Wenn alle Threads das Semaphor freigegeben haben, hat der Zähler den maximalen Wert, der beim Erstellen des Semaphors angegeben wurde.

Es gibt keine garantierte Reihenfolge (wie FIFO oder LIFO), in der dem Semaphor blockierte Threads hinzugefügt werden.

Ein Thread kann mehrmals in das Semaphor aufgenommen werden, indem die WaitOne-Methode wiederholt aufgerufen wird. Um mehrere oder alle dieser Einträge freizugeben, kann der Thread die Überladung der Release()-Methode ohne Parameter mehrfach aufrufen, oder er kann die Überladung der Release(Int32)-Methode aufrufen, die die Anzahl der freizugebenden Einträge angibt.

Die Semaphore-Klasse erzwingt keine Threadidentität für Aufrufe von WaitOne oder Release. Der Programmierer muss gewährleisten, dass Threads das Semaphor nicht zu oft freigeben. Angenommen, für ein Semaphor ist ein maximaler Zähler von 2 (zwei) festgelegt, und dem Semaphor wurden Thread A und Thread B hinzugefügt. Wenn Thread B durch einen Programmierfehler Release zweimal aufruft, dann sind beide Aufrufe erfolgreich. Die Anzahl für das Semaphor ist voll. Wenn Thread A schließlich Release aufruft, wird eine SemaphoreFullException ausgelöst.

Es gibt zwei Typen von Semaphoren: lokale Semaphore und benannte Systemsemaphore. Wenn Sie ein Semaphore-Objekt mit einem Konstruktor erstellen, der einen Namen akzeptiert, wird das Objekt einem Betriebssystemsemaphor mit demselben Namen zugeordnet. Benannte Systemsemaphore sind innerhalb des Betriebssystems sichtbar und können verwendet werden, um die Aktivitäten von Prozessen zu synchronisieren. Sie können mehrere Semaphore-Objekte erstellen, die dasselbe benannte Systemsemaphor darstellen, und Sie können ein vorhandenes benanntes Systemsemaphor mithilfe der OpenExisting-Methode öffnen.

Ein lokales Semaphor ist nur innerhalb des Prozesses vorhanden. Es kann von jedem Thread in einem Prozess verwendet werden, der einen Verweis auf das lokale Semaphore-Objekt enthält. Jedes Semaphore-Objekt ist ein separates lokales Semaphor.

HinweisHinweis

Das HostProtectionAttribute -Attribut, das auf diesen Typ oder Member angewendet wird, besitzt den folgenden Resources Eigenschaftswert: Synchronization | ExternalThreading. Das HostProtectionAttribute hat keine Auswirkungen auf Desktopanwendungen (die normalerweise durch Doppelklicken auf ein Symbol, Eingeben eines Befehls oder einer URL in einem Browser gestartet werden). Weitere Informationen finden Sie unter HostProtectionAttribute -Klasse oder SQL Server-Programmierung und Hostschutzattribute.

Im folgenden Codebeispiel wird ein Semaphor mit einem maximalen Zähler von 3 (drei) und einem anfänglichen Zähler von 0 (null) erstellt. Im Beispiel werden fünf Threads gestartet, die blockiert sind und auf das Semaphor warten. Der Hauptthread verwendet die Überladung der Release(Int32)-Methode, um den Zähler des Semaphors auf seinen Maximalwert zu setzen, sodass dem Semaphor drei Threads hinzugefügt werden können. Jeder Thread verwendet die Thread.Sleep-Methode, um eine Sekunde lang zu warten und Arbeit zu simulieren, und ruft dann die Überladung der Release()-Methode auf, um das Semaphor freizugeben. Jedes Mal, wenn das Semaphor freigegeben wird, wird der vorherige Semaphorzähler angezeigt. Die Verwendung des Semaphors wird durch Konsolenmeldungen überwacht. Das simulierte Arbeitsintervall wird für jeden Thread leicht erhöht, damit die Ausgabe leichter zu lesen ist.


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());
    }
}


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Dieser Typ ist threadsicher.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft