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 folgende Beispiel wird ein Semaphor mit einer maximalen Anzahl von drei Threads und eine anfängliche Anzahl von Threads erstellt.The following example creates a semaphore with a maximum count of three threads and an initial count of zero threads. Das Beispiel beginnt fünf Aufgaben, die das Semaphor warten blockieren.The example starts five tasks, all of which block waiting for the semaphore. Die Haupt-Thread Ruft die Release(Int32) -Überladung verwenden, um die Semaphorenanzahl ausschöpfen, erhöhen Sie die drei Aufgaben in das Semaphor ermöglicht.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 ist, wird die vorherige Anzahl des Semaphors angezeigt.Each time the semaphore is released, the previous semaphore count is displayed. Konsole Nachrichten nachverfolgen Semaphore verwenden.Console messages track semaphore use. Das Arbeiten mit simulierten Intervall wird für jeden Thread, um die Ausgabe leichter lesbar zu machen geringfügig erhöht.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

Gibt zwei Typen von Semaphoren: lokale Semaphore und benanntes Semaphore.Semaphores are of two types: local semaphores and named system semaphores. Die 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. Die SemaphoreSlim ist eine einfache Alternative zu den Semaphore -Klasse, die keine Windows-Kernel Semaphore verwendet.The SemaphoreSlim is a lightweight alternative to the Semaphore class that doesn't use Windows kernel semaphores. Im Gegensatz zu den Semaphore -Klasse, die SemaphoreSlim Klasse unterstützt keine benannten Systems Semaphoren.Unlike the Semaphore class, the SemaphoreSlim class doesn't support named system semaphores. Sie können es als nur ein lokales Semaphor verwenden.You can use it as a local semaphore only. Die SemaphoreSlim -Klasse ist die empfohlene Semaphor für die Synchronisierung innerhalb einer einzigen Anwendung.The SemaphoreSlim class is the recommended semaphore for synchronization within a single app.

Ein einfaches Semaphor steuert den Zugriff auf einen Pool von Ressourcen, 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 einen 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, 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 des Semaphors definiert.This defines the semaphore's count.

Die Anzahl ist dekrementiert jedes Mal ein Thread das Semaphor gibt, und inkrementiert jedes Mal 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 eingegeben haben, ein Thread Ruft eine von der Wait oder WaitAsync Überladungen.To enter the semaphore, a thread calls one of the Wait or WaitAsync overloads. Um das Semaphor freizugeben, ruft Sie eine der der Release Überladungen.To release the semaphore, it calls one of the Release overloads. Wenn die Anzahl 0 (null), und nachfolgende Aufrufe eines erreicht die Wait Methoden blockiert, bis andere Threads das Semaphor freizugeben.When the count reaches zero, subsequent calls to one of the Wait methods block until other threads release the semaphore. Wenn mehrere Threads blockiert sind, besteht keine festgelegte Reihenfolge, z. B. FIFO oder LIFO, die steuert, wenn Threads das Semaphor.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, einen Semaphor beim Schützen von Ressourcen verwendet, wird: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, wird die Anzahl die den maximalen Wert angegeben, wenn das Semaphor erstellt wurde.When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created. Die Anzahl des Semaphors steht über den CurrentCount Eigenschaft.The semaphore's count is available from the CurrentCount property.

Wichtig

Die SemaphoreSlim Klasse Aufrufe von Thread "oder" Task Identität erzwingt nicht die Wait, WaitAsync, und Release Methoden.The SemaphoreSlim class doesn't enforce thread or task identity on calls to the Wait, WaitAsync, and Release methods. Darüber hinaus Wenn die SemaphoreSlim(Int32) Konstruktor zum Instanziieren der SemaphoreSlim -Objekt, das CurrentCount Eigenschaft kann die durch den Konstruktor festgelegte Wert hinaus erhöhen.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. Es ist der Programmierer dafür verantwortlich sicherzustellen, die Aufrufe Wait oder WaitAsync Methoden werden entsprechend zugeordnet Aufrufe Release Methoden.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 der SemaphoreSlim sind threadsicher und können mit Ausnahme der gleichzeitig von mehreren Threads verwendet werden Dispose(), das verwendet werden, nur, wenn alle anderen Vorgänge in der SemaphoreSlim abgeschlossen haben.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