Semaphore Klasse

Definition

Namespace:

System.Threading

Assemblys:

netstandard.dll, System.Threading.dll

Quelle:

Semaphore.cs

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

public ref class Semaphore sealed : System::Threading::WaitHandle

public sealed class Semaphore : System.Threading.WaitHandle

type Semaphore = class
    inherit WaitHandle

Public NotInheritable Class Semaphore
Inherits WaitHandle

Vererbung

Object

MarshalByRefObject

WaitHandle

Semaphore

Beispiele

Im folgenden Codebeispiel wird ein Semaphor mit einer maximalen Anzahl von drei und einer Anfangsanzahl von Null erstellt. Das Beispiel startet fünf Threads, die auf das Semaphor warten. Der Hauptthread verwendet die Release(Int32) Methodenüberladung, um die Semaphoranzahl auf sein Maximum zu erhöhen, sodass drei Threads in das Semaphor gelangen können. Jeder Thread verwendet die Thread.Sleep Methode, um eine Sekunde zu warten, um Arbeit zu simulieren, und ruft dann die Release() Methodenüberladung auf, um das Semaphor freizugeben. Jedes Mal, wenn der Semaphor losgelassen wird, wird die vorherige Semaphoranzahl angezeigt. Konsolennachrichten verfolgen die Verwendung von Semaphoren. Das simulierte Arbeitsintervall wird für jeden Thread leicht erhöht, um die Ausgabe leichter lesbar zu machen.

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(initialCount: 0, maximumCount: 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(releaseCount: 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());
    }
}

Imports System.Threading

Public Class Example

    ' A semaphore that simulates a limited resource pool.
    '
    Private Shared _pool As Semaphore

    ' A padding interval to make the output more orderly.
    Private Shared _padding As Integer

    <MTAThread> _
    Public Shared Sub 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 i As Integer = 1 To 5
            Dim t As New Thread(New ParameterizedThreadStart(AddressOf Worker))
            'Dim t As New Thread(AddressOf Worker)

            ' Start the thread, passing the number.
            '
            t.Start(i)
        Next 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.")
    End Sub

    Private Shared Sub Worker(ByVal num As Object)
        ' 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.
        Dim padding As Integer = Interlocked.Add(_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())
    End Sub
End Class

Hinweise

Verwenden Sie die Semaphore Klasse, um den Zugriff auf einen Ressourcenpool zu steuern. Threads geben das Semaphor ein, indem die WaitOne Methode aufgerufen wird, die von der WaitHandle Klasse geerbt wird, und geben Sie das Semaphor durch Aufrufen der Release Methode frei.

Die Anzahl eines Semaphors wird jedes Mal, wenn ein Thread in das Semaphor eintritt, erhöht und erhöht, wenn ein Thread das Semaphor loslässt. Wenn die Anzahl null ist, werden nachfolgende Anforderungen blockiert, bis andere Threads das Semaphor freigeben. Wenn alle Threads das Semaphor freigegeben haben, liegt die Anzahl beim Erstellen des Semaphors bei dem angegebenen Höchstwert.

Es gibt keine garantierte Reihenfolge, z. B. FIFO oder LIFO, in der blockierte Threads in das Semaphor gelangen.

Ein Thread kann mehrmals in das Semaphor eintreten, indem die WaitOne Methode wiederholt aufgerufen wird. Um einige oder alle dieser Einträge freizugeben, kann der Thread die parameterlose Release() Methodenüberladung mehrmals aufrufen oder die Methodenüberladung aufrufen, die Release(Int32) die Anzahl der zu veröffentlichenden Einträge angibt.

Die Semaphore Klasse erzwingt keine Threadidentität für Aufrufe von WaitOne oder Release. Es liegt in der Verantwortung des Programmierers, sicherzustellen, dass Threads das Semaphor nicht zu oft freigeben. Angenommen, ein Semaphor hat eine maximale Anzahl von zwei, und Thread A und Thread B betreten beide das Semaphor. Wenn ein Programmierfehler in Thread B dazu führt, dass Release zweimal aufgerufen wird, sind beide Aufrufe erfolgreich. Der Zähler des Semaphors ist voll, und wenn Thread A schließlich Release aufruft, wird eine SemaphoreFullException ausgelöst.

Semaphore sind von zwei Arten: lokale Semaphore und benannte Systemsemaphoren. Wenn Sie ein Semaphore Objekt mit einem Konstruktor erstellen, der einen Namen akzeptiert, wird es einem Betriebssystem-Semaphor dieses Namens zugeordnet. Benannte System-Semaphore sind im gesamten Betriebssystem sichtbar und können verwendet werden, um die Aktivitäten von Prozessen zu synchronisieren. Sie können mehrere Semaphore Objekte erstellen, die denselben benannten Systemsemaphor darstellen, und Sie können die OpenExisting Methode verwenden, um ein vorhandenes benanntes System-Semaphor zu öffnen.

Ein lokales Semaphor ist nur innerhalb Ihres Prozesses vorhanden. Sie kann von jedem Thread in Ihrem Prozess verwendet werden, der über einen Verweis auf das lokale Semaphore Objekt verfügt. Jedes Semaphore Objekt ist ein separates lokales Semaphor.

Vorsicht

Standardmäßig ist ein benannter Semaphor nicht auf den Benutzer beschränkt, der ihn erstellt hat. Andere Benutzer können das Semaphor öffnen und verwenden, einschließlich der Störung des Semaphors, indem sie das Semaphor mehrmals erwerben und nicht freigeben. Um den Zugriff auf bestimmte Benutzer einzuschränken, können Sie eine Konstruktorüberladung verwenden oder SemaphoreAcl beim Erstellen des benannten Semaphors übergeben und übergeben SemaphoreSecurity . Vermeiden Sie die Verwendung von benannten Semaphoren ohne Zugriffsbeschränkungen für Systeme, die möglicherweise nicht vertrauenswürdige Benutzer mit Code ausführen.

Konstruktoren

Name	Beschreibung
Semaphore(Int32, Int32, String, Boolean)	Initialisiert eine neue Instanz der Semaphore Klasse, die die anfängliche Anzahl von Einträgen und die maximale Anzahl gleichzeitiger Einträge angibt, optional den Namen eines System-Semaphorobjekts angibt und eine Variable angibt, die einen Wert empfängt, der angibt, ob ein neues System-Semaphor erstellt wurde.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions, Boolean)	Initialisiert eine neue Instanz der Semaphore Klasse, die die anfängliche Anzahl von Einträgen und die maximale Anzahl gleichzeitiger Einträge angibt, optional den Namen eines System-Semaphorobjekts und Optionen zum Festlegen des Benutzerbereichs- und Sitzungsbereichszugriffs und angeben eine Variable, die einen Wert erhält, der angibt, ob ein neues System-Semaphor erstellt wurde.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions)	Initialisiert eine neue Instanz der Semaphore Klasse, die die anfängliche Anzahl von Einträgen und die maximale Anzahl gleichzeitiger Einträge angibt und optional den Namen eines System-Semaphorobjekts und Optionen zum Festlegen des Benutzerbereichs und des Sitzungsbereichszugriffs angibt.
Semaphore(Int32, Int32, String)	Initialisiert eine neue Instanz der Semaphore Klasse, die die anfängliche Anzahl von Einträgen und die maximale Anzahl gleichzeitiger Einträge angibt und optional den Namen eines System-Semaphorobjekts angibt.
Semaphore(Int32, Int32)	Initialisiert eine neue Instanz der Semaphore Klasse, wobei die anfängliche Anzahl von Einträgen und die maximale Anzahl gleichzeitiger Einträge angegeben wird.

Felder

Name	Beschreibung
WaitTimeout	Gibt an, dass ein WaitAny(WaitHandle[], Int32, Boolean) Vorgang überschritten wurde, bevor ein Wartepunkt signalisiert wurde. Dieses Feld ist konstant. (Geerbt von WaitHandle)

Eigenschaften

Name	Beschreibung
Handle	Veraltet. Dient zum Abrufen oder Festlegen des systemeigenen Betriebssystemhandles. (Geerbt von WaitHandle)
SafeWaitHandle	Dient zum Abrufen oder Festlegen des systemeigenen Betriebssystemhandles. (Geerbt von WaitHandle)

Methoden

Name	Beschreibung
Close()	Veröffentlicht alle Ressourcen, die von der aktuellen WaitHandle. (Geerbt von WaitHandle)
Dispose()	Gibt alle Ressourcen frei, die von der aktuellen Instanz der WaitHandle Klasse verwendet werden. (Geerbt von WaitHandle)
Dispose(Boolean)	Wenn sie in einer abgeleiteten Klasse überschrieben werden, werden die nicht verwalteten Ressourcen freigegeben, die von den WaitHandleverwalteten Ressourcen verwendet werden, und optional die verwalteten Ressourcen freigegeben. (Geerbt von WaitHandle)
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject Objekts. (Geerbt von MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist. Wenn die Optionen nur auf den aktuellen Benutzer festgelegt sind, werden die Zugriffssteuerungen des Objekts für den aufrufenden Benutzer überprüft.
OpenExisting(String)	Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist.
Release()	Beendet das Semaphor und gibt die vorherige Anzahl zurück.
Release(Int32)	Beendet das Semaphor mit einer angegebenen Anzahl von Malen und gibt die vorherige Anzahl zurück.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TryOpenExisting(String, NamedWaitHandleOptions, Semaphore)	Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war. Wenn die Optionen nur auf den aktuellen Benutzer festgelegt sind, werden die Zugriffssteuerungen des Objekts für den aufrufenden Benutzer überprüft.
TryOpenExisting(String, Semaphore)	Öffnet den angegebenen benannten Semaphor, sofern er bereits vorhanden ist, und gibt einen Wert zurück, der angibt, ob der Vorgang erfolgreich war.
WaitOne()	Blockiert den aktuellen Thread, bis der aktuelle WaitHandle Thread ein Signal empfängt. (Geerbt von WaitHandle)
WaitOne(Int32, Boolean)	Blockiert den aktuellen Thread, bis der aktuelle WaitHandle Thread ein Signal empfängt, wobei eine 32-Bit-ganzzahl mit Vorzeichen verwendet wird, um das Zeitintervall anzugeben und anzugeben, ob die Synchronisierungsdomäne vor dem Warten beendet werden soll. (Geerbt von WaitHandle)
WaitOne(Int32)	Blockiert den aktuellen Thread, bis der aktuelle WaitHandle Thread ein Signal empfängt, wobei eine 32-Bit-ganzzahl mit Vorzeichen verwendet wird, um das Zeitintervall in Millisekunden anzugeben. (Geerbt von WaitHandle)
WaitOne(TimeSpan, Boolean)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei ein TimeSpan Zeitintervall angegeben und angegeben wird, ob die Synchronisierungsdomäne vor der Wartezeit beendet werden soll. (Geerbt von WaitHandle)
WaitOne(TimeSpan)	Blockiert den aktuellen Thread, bis die aktuelle Instanz ein Signal empfängt, wobei ein TimeSpan Zeitintervall angegeben wird. (Geerbt von WaitHandle)

Erweiterungsmethoden

Name	Beschreibung
GetAccessControl(Semaphore)	Gibt die Sicherheitsbeschreibungen für den angegebenen semaphoreWert zurück.
GetSafeWaitHandle(WaitHandle)	Ruft das sichere Handle für ein systemeigenes Betriebssystem-Wait Handle ab.
SetAccessControl(Semaphore, SemaphoreSecurity)	Legt die Sicherheitsdeskriptoren für das angegebene Semaphor fest.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Legt einen sicheren Handle für ein systemeigenes Betriebssystem-Wait Handle fest.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• Verwaltetes Thread-Management
• Semaphor