Semaphore Třída

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Threading.dll

Zdroj:

Semaphore.cs

Omezuje počet vláken, která můžou současně přistupovat k prostředku nebo fondu prostředků.

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

Dědičnost

Object

MarshalByRefObject

WaitHandle

Semaphore

Příklady

Následující příklad kódu vytvoří semaphore s maximálním počtem tří a počátečním počtem nuly. Příklad spustí pět vláken, které blok čekají na semafor. Hlavní vlákno používá Release(Int32) přetížení metody ke zvýšení počtu semaphore na jeho maximum, což umožňuje tři vlákna vstoupit do semaphore. Každé vlákno používá metodu Thread.Sleep k čekání na jednu sekundu, k simulaci práce a pak volá Release() přetížení metody k uvolnění semaphore. Při každém uvolnění semaforu se zobrazí předchozí semafor. Zprávy konzoly sledují použití semaphore. Simulovaný pracovní interval se pro každé vlákno mírně zvýší, aby se výstup snadněji četl.

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

Poznámky

Semaphore Pomocí třídy můžete řídit přístup k fondu prostředků. Vlákna zadávají semaphore voláním WaitOne metody, která je zděděna z WaitHandle třídy, a uvolnění semaphore voláním Release metody.

Počet semaforu se při každém vstupu vlákna do semaforu sníží a zvýší se, když vlákno uvolní semaphore. Pokud je počet nula, následné požadavky blokují, dokud ostatní vlákna nevolí semafor. Když všechna vlákna uvolní semaphore, počet je maximální hodnota zadaná při vytvoření semaforu.

Neexistuje žádné zaručené pořadí, například FIFO nebo LIFO, ve kterém blokovaná vlákna zadávají semafor.

Vlákno může několikrát zadat semaphore voláním WaitOne metody opakovaně. Chcete-li uvolnit některé nebo všechny tyto položky, vlákno může volat přetížení metody bez Release() parametrů vícekrát, nebo může volat Release(Int32) přetížení metody, která určuje počet položek, které mají být vydány.

Třída Semaphore nevynucuje identitu vlákna pro volání WaitOne nebo Release. Je zodpovědností programátora zajistit, aby vlákna neuvolňovat semaphore příliš mnohokrát. Předpokládejme například, že semafor má maximální počet dvou a že vlákno A a vlákno B vstoupí do semaforu. Pokud programovací chyba ve vlákně B způsobí, že se volá Release dvakrát, obě volání proběhnou úspěšně. Počet na semaforu je plný a když vlákno A nakonec zavolá Release, je vyvolána výjimka SemaphoreFullException.

Semafory jsou dvou typů: místní semaphores a pojmenované systémové semafory. Pokud vytvoříte Semaphore objekt pomocí konstruktoru, který přijímá název, je přidružen k semaforu operačního systému tohoto názvu. Pojmenované systémové semafory jsou viditelné v celém operačním systému a lze je použít k synchronizaci aktivit procesů. Můžete vytvořit více Semaphore objektů, které představují stejný pojmenovaný systém semaphore, a můžete použít metodu OpenExisting k otevření existující pojmenované systémové semaphore.

Místní semaphore existuje pouze v rámci vašeho procesu. Může ho použít libovolné vlákno v procesu, které má odkaz na místní Semaphore objekt. Každý Semaphore objekt je samostatný místní semafor.

Caution

Ve výchozím nastavení není pojmenovaný semaphore omezen na uživatele, který ho vytvořil. Ostatní uživatelé můžou být schopni otevřít a použít semafor, včetně narušení semaforu tím, že ho několikrát získají a nevyvolá. Chcete-li omezit přístup na konkrétní uživatele, můžete použít přetížení konstruktoru nebo SemaphoreAcl předat při vytváření pojmenované SemaphoreSecurity semaphore. Nepoužívejte pojmenované semafory bez omezení přístupu v systémech, které můžou mít nedůvěryhodné uživatele se spuštěným kódem.

Konstruktory

Name	Description
Semaphore(Int32, Int32, String, Boolean)	Inicializuje novou instanci Semaphore třídy, určuje počáteční počet položek a maximální počet souběžných položek, volitelně zadat název objektu semaphore systému a zadat proměnnou, která obdrží hodnotu určující, zda byl vytvořen nový systémový semaphore.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions, Boolean)	Inicializuje novou instanci Semaphore třídy, určuje počáteční počet položek a maximální počet souběžných položek, volitelně zadáním názvu objektu semaphore systému a možností pro nastavení uživatelského oboru a oboru relace a určení proměnné, která obdrží hodnotu určující, zda byl vytvořen nový systémový semaphore.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions)	Inicializuje novou instanci Semaphore třídy, zadá počáteční počet položek a maximální počet souběžných položek a volitelně zadá název objektu semaphore systému a možnosti pro nastavení přístupu k oboru uživatele a relace.
Semaphore(Int32, Int32, String)	Inicializuje novou instanci Semaphore třídy, určuje počáteční počet položek a maximální počet souběžných položek a volitelně zadat název systémového semaphore objektu.
Semaphore(Int32, Int32)	Inicializuje novou instanci Semaphore třídy, určuje počáteční počet položek a maximální počet souběžných položek.

Pole

Name	Description
WaitTimeout	Označuje, že WaitAny(WaitHandle[], Int32, Boolean) operace vypršela před signálem jakéhokoli z popisovačů čekání. Toto pole je konstantní. (Zděděno od WaitHandle)

Vlastnosti

Name	Description
Handle	Zastaralé. Získá nebo nastaví nativní popisovač operačního systému. (Zděděno od WaitHandle)
SafeWaitHandle	Získá nebo nastaví nativní popisovač operačního systému. (Zděděno od WaitHandle)

Metody

Name	Description
Close()	Uvolní všechny prostředky uchovávané aktuálním WaitHandle. (Zděděno od WaitHandle)
Dispose()	Uvolní všechny prostředky používané aktuální instancí WaitHandle třídy. (Zděděno od WaitHandle)
Dispose(Boolean)	Při přepsání v odvozené třídě uvolní nespravované prostředky používané nástrojem WaitHandlea volitelně uvolní spravované prostředky. (Zděděno od WaitHandle)
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Otevře zadaný název semaphore, pokud již existuje. Pokud jsou možnosti nastaveny pouze na aktuálního uživatele, ověří se u volajícího uživatele řízení přístupu objektu.
OpenExisting(String)	Otevře zadaný název semaphore, pokud již existuje.
Release()	Ukončí semafor a vrátí předchozí počet.
Release(Int32)	Ukončí semafor zadaného počtu a vrátí předchozí počet.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
TryOpenExisting(String, NamedWaitHandleOptions, Semaphore)	Otevře zadaný pojmenovaný semaphore, pokud již existuje, a vrátí hodnotu, která označuje, zda operace proběhla úspěšně. Pokud jsou možnosti nastaveny pouze na aktuálního uživatele, ověří se u volajícího uživatele řízení přístupu objektu.
TryOpenExisting(String, Semaphore)	Otevře zadaný pojmenovaný semaphore, pokud již existuje, a vrátí hodnotu, která označuje, zda operace proběhla úspěšně.
WaitOne()	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál. (Zděděno od WaitHandle)
WaitOne(Int32, Boolean)	Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určí časový interval a určí, jestli se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)
WaitOne(Int32)	Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určuje časový interval v milisekundách. (Zděděno od WaitHandle)
WaitOne(TimeSpan, Boolean)	Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan a určí, zda se má před čekáním ukončit synchronizační doména. (Zděděno od WaitHandle)
WaitOne(TimeSpan)	Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí TimeSpan k určení časového intervalu. (Zděděno od WaitHandle)

Metody rozšíření

Name	Description
GetAccessControl(Semaphore)	Vrátí popisovače zabezpečení pro zadanou semaphorehodnotu .
GetSafeWaitHandle(WaitHandle)	Získá bezpečný popisovač pro nativní obslužný rutina čekání operačního systému.
SetAccessControl(Semaphore, SemaphoreSecurity)	Nastaví popisovače zabezpečení pro zadaný semafor.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Nastaví bezpečný popisovač pro nativní obslužný rutinu čekání operačního systému.

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.

Viz také

• spravovaných vláken
• Semafor