SemaphoreSlim SemaphoreSlim SemaphoreSlim SemaphoreSlim Class

Definition

Eine einfache Alternative zu Semaphore, die die Anzahl der Threads beschränkt, die gleichzeitig auf eine Ressource oder einen Ressourcenpool zugreifen können.Represents a lightweight alternative to Semaphore that limits the number of threads that can access a resource or pool of resources concurrently.

public ref class SemaphoreSlim : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class SemaphoreSlim : IDisposable
type SemaphoreSlim = class
    interface IDisposable
Public Class SemaphoreSlim
Implements IDisposable
Vererbung
SemaphoreSlimSemaphoreSlimSemaphoreSlimSemaphoreSlim
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird ein Semaphor mit einer maximalen Anzahl von drei Threads und einer anfänglichen Anzahl von NULL-Threads erstellt.The following example creates a semaphore with a maximum count of three threads and an initial count of zero threads. Im Beispiel werden fünf Aufgaben gestartet, die alle blockieren, die auf das Semaphor warten.The example starts five tasks, all of which block waiting for the semaphore. Der Haupt Thread ruft die Release(Int32) -Überladung auf, um die Anzahl der Semaphor auf den maximalen Wert zu erhöhen. Dadurch können drei Aufgaben in das Semaphor eintreten.The main thread calls the Release(Int32) overload to increase the semaphore count to its maximum, which allows three tasks to enter the semaphore. Jedes Mal, wenn das Semaphor freigegeben wird, wird die vorherige Semaphor-Anzahl angezeigt.Each time the semaphore is released, the previous semaphore count is displayed. Konsolen Meldungen verfolgen die Verwendung von Semaphor.Console messages track semaphore use. Das simulierte Arbeitsintervall wird für jeden Thread geringfügig angehoben, damit die Ausgabe leichter lesbar ist.The simulated work interval is increased slightly for each thread to make the output easier to read.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    private static SemaphoreSlim semaphore;
    // A padding interval to make the output more orderly.
    private static int padding;

    public static void Main()
    {
        // Create the semaphore.
        semaphore = new SemaphoreSlim(0, 3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        Task[] tasks = new Task[5];
        
        // Create and start five numbered tasks.
        for(int i = 0; i <= 4; i++)
        {
            tasks[i] = Task.Run( () => {
            // Each task begins by requesting the semaphore.
            Console.WriteLine("Task {0} begins and waits for the semaphore.",
                              Task.CurrentId);
            semaphore.Wait();

            Interlocked.Add(ref padding, 100);

            Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId);

            // The task just sleeps for 1+ seconds.
            Thread.Sleep(1000 + padding);

            Console.WriteLine("Task {0} releases the semaphore; previous count: {1}.",
                              Task.CurrentId, semaphore.Release()); } );
        }

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

        // Restore the semaphore count to its maximum value.
        Console.Write("Main thread calls Release(3) --> ");
        semaphore.Release(3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        // Main thread waits for the tasks to complete.
        Task.WaitAll(tasks);
        
        Console.WriteLine("Main thread exits.");
    }
}
// The example displays output like the following:
//       0 tasks can enter the semaphore.
//       Task 1 begins and waits for the semaphore.
//       Task 5 begins and waits for the semaphore.
//       Task 2 begins and waits for the semaphore.
//       Task 4 begins and waits for the semaphore.
//       Task 3 begins and waits for the semaphore.
//       Main thread calls Release(3) --> 3 tasks can enter the semaphore.
//       Task 4 enters the semaphore.
//       Task 1 enters the semaphore.
//       Task 3 enters the semaphore.
//       Task 4 releases the semaphore; previous count: 0.
//       Task 2 enters the semaphore.
//       Task 1 releases the semaphore; previous count: 0.
//       Task 3 releases the semaphore; previous count: 0.
//       Task 5 enters the semaphore.
//       Task 2 releases the semaphore; previous count: 1.
//       Task 5 releases the semaphore; previous count: 2.
//       Main thread exits.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Private semaphore As SemaphoreSlim
    ' A padding interval to make the output more orderly.
    Private padding As Integer

   Public Sub Main()
      ' Create the semaphore.
      semaphore = New SemaphoreSlim(0, 3)
      Console.WriteLine("{0} tasks can enter the semaphore.",
                        semaphore.CurrentCount)
      Dim tasks(4) As Task

      ' Create and start five numbered tasks.
      For i As Integer = 0 To 4
         tasks(i) = Task.Run(
            Sub()
               ' Each task begins by requesting the semaphore.
               Console.WriteLine("Task {0} begins and waits for the semaphore.",
                              Task.CurrentId)
               semaphore.Wait()

               Interlocked.Add(padding, 100)

               Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId)

               ' The task just sleeps for 1+ seconds.
               Thread.Sleep(1000 + padding)

               Console.WriteLine("Task {0} releases the semaphore previous count: {1}.",
                                 Task.CurrentId, semaphore.Release())
            End Sub )
      Next

      ' Wait for half a second, to allow all the tasks to start and block.
      Thread.Sleep(500)

      ' Restore the semaphore count to its maximum value.
      Console.Write("Main thread calls Release(3) --> ")
      semaphore.Release(3)
      Console.WriteLine("{0} tasks can enter the semaphore.",
                        semaphore.CurrentCount)
      ' Main thread waits for the tasks to complete.
      Task.WaitAll(tasks)

      Console.WriteLine("Main thread exits.")
   End Sub
End Module
' The example displays output like the following:
'       0 tasks can enter the semaphore.
'       Task 1 begins and waits for the semaphore.
'       Task 5 begins and waits for the semaphore.
'       Task 2 begins and waits for the semaphore.
'       Task 4 begins and waits for the semaphore.
'       Task 3 begins and waits for the semaphore.
'       Main thread calls Release(3) --> 3 tasks can enter the semaphore.
'       Task 4 enters the semaphore.
'       Task 1 enters the semaphore.
'       Task 3 enters the semaphore.
'       Task 4 releases the semaphore; previous count: 0.
'       Task 2 enters the semaphore.
'       Task 1 releases the semaphore; previous count: 0.
'       Task 3 releases the semaphore; previous count: 0.
'       Task 5 enters the semaphore.
'       Task 2 releases the semaphore; previous count: 1.
'       Task 5 releases the semaphore; previous count: 2.
'       Main thread exits.

Hinweise

Semaphoren haben zwei Typen: lokale Semaphoren und benannte System Semaphoren.Semaphores are of two types: local semaphores and named system semaphores. Das erste ist für eine APP lokal.The former is local to an app. Letzteres ist im gesamten Betriebssystem sichtbar und eignet sich für die prozessübergreifende Synchronisierung.The latter is visible throughout the operating system and is suitable for inter-process synchronization. Ist eine vereinfachte Alternative zu der Semaphore -Klasse, die keine Windows Kernel Semaphore verwendet. SemaphoreSlimThe SemaphoreSlim is a lightweight alternative to the Semaphore class that doesn't use Windows kernel semaphores. Anders als Semaphore die-Klasse SemaphoreSlim unterstützt die-Klasse benannte System Semaphore nicht.Unlike the Semaphore class, the SemaphoreSlim class doesn't support named system semaphores. Sie können Sie nur als lokales Semaphor verwenden.You can use it as a local semaphore only. Die SemaphoreSlim -Klasse ist das empfohlene Semaphor für die Synchronisierung innerhalb einer einzelnen app.The SemaphoreSlim class is the recommended semaphore for synchronization within a single app.

Ein schlankes Semaphor steuert den Zugriff auf einen Ressourcenpool, der für Ihre Anwendung lokal ist.A lightweight semaphore controls access to a pool of resources that is local to your application. Wenn Sie ein Semaphor instanziieren, können Sie die maximale Anzahl von Threads angeben, die das Semaphor gleichzeitig eingeben können.When you instantiate a semaphore, you can specify the maximum number of threads that can enter the semaphore concurrently. Außerdem geben Sie die anfängliche Anzahl von Threads an, die das Semaphor gleichzeitig eingeben können.You also specify the initial number of threads that can enter the semaphore concurrently. Dadurch wird die Anzahl der Semaphore definiert.This defines the semaphore's count.

Die Anzahl wird jedes Mal dekrementiert, wenn ein Thread in das Semaphor eintritt, und erhöht sich jedes Mal, wenn ein Thread das Semaphor freigibt.The count is decremented each time a thread enters the semaphore, and incremented each time a thread releases the semaphore. Um das Semaphor einzugeben, Ruft ein Thread eine der Wait -oder WaitAsync -über Ladungen auf.To enter the semaphore, a thread calls one of the Wait or WaitAsync overloads. Um das Semaphor freizugeben, wird eine der Release -über Ladungen aufgerufen.To release the semaphore, it calls one of the Release overloads. Wenn die Anzahl Null erreicht, werden nachfolgende Aufrufe von einer Wait der Methoden blockiert, bis andere Threads das Semaphor freigeben.When the count reaches zero, subsequent calls to one of the Wait methods block until other threads release the semaphore. Wenn mehrere Threads blockiert werden, gibt es keine garantierte Reihenfolge (z. b. FIFO oder LIFO), mit der gesteuert wird, wann Threads in das Semaphor eintreten.If multiple threads are blocked, there is no guaranteed order, such as FIFO or LIFO, that controls when threads enter the semaphore.

Die grundlegende Struktur für Code, der ein Semaphor zum Schützen von Ressourcen verwendet, ist:The basic structure for code that uses a semaphore to protect resources is:


' Enter semaphore by calling one of the Wait or WaitAsync methods.  
SemaphoreSlim.Wait()  
'   
' Execute code protected by the semaphore.   
'  
SemaphoreSlim.Release()  

Wenn alle Threads das Semaphor freigegeben haben, liegt die Anzahl bei dem maximalen Wert, der beim Erstellen des Semaphors angegeben wurde.When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created. Die Anzahl der Semaphore ist über die CurrentCount -Eigenschaft verfügbar.The semaphore's count is available from the CurrentCount property.

Wichtig

Die SemaphoreSlim -Klasse erzwingt keine Thread-oder Aufgaben Identität bei Waitaufrufen WaitAsyncder Methoden Release , und.The SemaphoreSlim class doesn't enforce thread or task identity on calls to the Wait, WaitAsync, and Release methods. Wenn der SemaphoreSlim(Int32) -Konstruktor verwendet wird, um das SemaphoreSlim -Objekt zu instanziieren, CurrentCount kann die-Eigenschaft außerdem über den vom-Konstruktor festgelegten Wert hinaus zunehmen.In addition, if the SemaphoreSlim(Int32) constructor is used to instantiate the SemaphoreSlim object, the CurrentCount property can increase beyond the value set by the constructor. Der Programmierer ist dafür verantwortlich, sicherzustellen, dass Aufrufe Wait der WaitAsync -Methode oder der-Methode Ordnungs Release gemäß mit Aufrufen von-Methoden gekoppelt werden.It is the programmer's responsibility to ensure that calls to Wait or WaitAsync methods are appropriately paired with calls to Release methods.

Konstruktoren

SemaphoreSlim(Int32) SemaphoreSlim(Int32) SemaphoreSlim(Int32) SemaphoreSlim(Int32)

Initialisiert eine neue Instanz der SemaphoreSlim-Klasse und gibt die ursprüngliche Anzahl von Anforderungen an, die gleichzeitig gewährt werden können.Initializes a new instance of the SemaphoreSlim class, specifying the initial number of requests that can be granted concurrently.

SemaphoreSlim(Int32, Int32) SemaphoreSlim(Int32, Int32) SemaphoreSlim(Int32, Int32) SemaphoreSlim(Int32, Int32)

Initialisiert eine neue Instanz der SemaphoreSlim-Klasse und gibt die ursprüngliche sowie die maximale Anzahl von Anforderungen an, die gleichzeitig gewährt werden können.Initializes a new instance of the SemaphoreSlim class, specifying the initial and maximum number of requests that can be granted concurrently.

Eigenschaften

AvailableWaitHandle AvailableWaitHandle AvailableWaitHandle AvailableWaitHandle

Gibt ein WaitHandle zurück, das verwendet werden kann um auf die Semaphore zu warten.Returns a WaitHandle that can be used to wait on the semaphore.

CurrentCount CurrentCount CurrentCount CurrentCount

Ruft die Anzahl der verbleibenden Threads ab, für die das Eintreten in das SemaphoreSlim-Objekt zulässig ist.Gets the number of remaining threads that can enter the SemaphoreSlim object.

Methoden

Dispose() Dispose() Dispose() Dispose()

Gibt alle von der aktuellen Instanz der SemaphoreSlim-Klasse verwendeten Ressourcen frei.Releases all resources used by the current instance of the SemaphoreSlim class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt die von SemaphoreSlim verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the SemaphoreSlim, and optionally releases the managed resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Release() Release() Release() Release()

Gibt das SemaphoreSlim-Objekt einmal frei.Releases the SemaphoreSlim object once.

Release(Int32) Release(Int32) Release(Int32) Release(Int32)

Gibt das SemaphoreSlim-Objekt eine festgelegte Anzahl von Malen frei.Releases the SemaphoreSlim object a specified number of times.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)
Wait() Wait() Wait() Wait()

Blockiert den aktuellen Thread, bis er in die Warteschlange von SemaphoreSlim eingereiht werden kann.Blocks the current thread until it can enter the SemaphoreSlim.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Blockiert den aktuellen Thread, bis er in die Warteschlange von SemaphoreSlim eingereiht werden kann, wobei ein CancellationToken überwacht wird.Blocks the current thread until it can enter the SemaphoreSlim, while observing a CancellationToken.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Blockiert den aktuellen Thread, bis er in die Warteschlange von SemaphoreSlim eingereiht werden kann, wobei das Timeout mit einer 32-Bit-Ganzzahl mit Vorzeichen angegeben wird.Blocks the current thread until it can enter the SemaphoreSlim, using a 32-bit signed integer that specifies the timeout.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Blockiert den aktuellen Thread, bis er in die Warteschlange von SemaphoreSlim eingereiht werden kann, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Angeben des Timeouts verwendet und ein CancellationToken überwacht wird.Blocks the current thread until it can enter the SemaphoreSlim, using a 32-bit signed integer that specifies the timeout, while observing a CancellationToken.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Blockiert den aktuellen Thread, bis er in die Warteschlange von SemaphoreSlim eingereiht werden kann, wobei ein TimeSpan zum Angeben des Timeouts verwendet wird.Blocks the current thread until it can enter the SemaphoreSlim, using a TimeSpan to specify the timeout.

Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken) Wait(TimeSpan, CancellationToken)

Blockiert den aktuellen Thread, bis er in die Warteschlange von SemaphoreSlim eingereiht werden kann, wobei eine TimeSpan den Timeout angibt und ein CancellationToken überwacht wird.Blocks the current thread until it can enter the SemaphoreSlim, using a TimeSpan that specifies the timeout, while observing a CancellationToken.

WaitAsync() WaitAsync() WaitAsync() WaitAsync()

Wartet asynchron auf den Zutritt zum SemaphoreSlim.Asynchronously waits to enter the SemaphoreSlim.

WaitAsync(CancellationToken) WaitAsync(CancellationToken) WaitAsync(CancellationToken) WaitAsync(CancellationToken)

Wartet asynchron auf den Zutritt zum SemaphoreSlim, während ein ein CancellationToken beobachtet wird.Asynchronously waits to enter the SemaphoreSlim, while observing a CancellationToken.

WaitAsync(Int32) WaitAsync(Int32) WaitAsync(Int32) WaitAsync(Int32)

Wartet asynchron auf den Zutritt zum SemaphoreSlim, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird.Asynchronously waits to enter the SemaphoreSlim, using a 32-bit signed integer to measure the time interval.

WaitAsync(Int32, CancellationToken) WaitAsync(Int32, CancellationToken) WaitAsync(Int32, CancellationToken) WaitAsync(Int32, CancellationToken)

Wartet asynchron auf den Zutritt zum SemaphoreSlim, wobei eine 32-Bit-Ganzzahl mit Vorzeichen zum Messen des Zeitintervalls verwendet wird, während ein CancellationToken beobachtet wird.Asynchronously waits to enter the SemaphoreSlim, using a 32-bit signed integer to measure the time interval, while observing a CancellationToken.

WaitAsync(TimeSpan) WaitAsync(TimeSpan) WaitAsync(TimeSpan) WaitAsync(TimeSpan)

Wartet asynchron auf den Zutritt zum SemaphoreSlim unter Verwendung einer TimeSpan zum Messen des Zeitintervalls.Asynchronously waits to enter the SemaphoreSlim, using a TimeSpan to measure the time interval.

WaitAsync(TimeSpan, CancellationToken) WaitAsync(TimeSpan, CancellationToken) WaitAsync(TimeSpan, CancellationToken) WaitAsync(TimeSpan, CancellationToken)

Wartet asynchron auf den Zutritt zum SemaphoreSlim unter Verwendung einer TimeSpan zum Messen des Zeitintervalls, während ein CancellationToken beobachtet wird.Asynchronously waits to enter the SemaphoreSlim, using a TimeSpan to measure the time interval, while observing a CancellationToken.

Gilt für:

Threadsicherheit

Alle öffentlichen und geschützten Member von SemaphoreSlim sind Thread sicher und können gleichzeitig von mehreren Threads verwendet werden, mit Ausnahme von Dispose(), die nur verwendet werden muss, wenn alle anderen Vorgänge in der SemaphoreSlim abgeschlossen sind.All public and protected members of SemaphoreSlim are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose(), which must be used only when all other operations on the SemaphoreSlim have completed.

Siehe auch