Semaphore Konstruktory

Definice

Obor názvů:

System.Threading

Sestavení:

System.Threading.dll

Inicializuje novou instanci Semaphore třídy.

Přetížení

Semaphore(Int32, Int32)	Inicializuje novou instanci Semaphore třídy zadáním počátečního počtu položek a maximálního počtu souběžných položek.
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ě určuje název systémového semaforu objektu.
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ě určuje název systémového semafor objektu a určuje proměnnou, která obdrží hodnotu označující, zda byl vytvořen nový systémový semafor.

Semaphore(Int32, Int32)

Zdroj:

Semaphore.cs

Inicializuje novou instanci Semaphore třídy zadáním počátečního počtu položek a maximálního počtu souběžných položek.

public:
 Semaphore(int initialCount, int maximumCount);

public Semaphore (int initialCount, int maximumCount);

new System.Threading.Semaphore : int * int -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer)

Parametry

initialCount

Int32

Počáteční počet požadavků na semafor, které lze udělit současně.

maximumCount

Int32

Maximální počet požadavků na semafor, které lze udělit současně.

Výjimky

ArgumentException

initialCount je větší než maximumCount.

ArgumentOutOfRangeException

maximumCount je menší než 1.

-nebo-

initialCount je menší než 0.

Příklady

Následující příklad vytvoří semafor 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 zvýšit počet semaforu na své maximum, což umožňuje tři vlákna vstoupit semafor. Každé vlákno používá metodu Thread.Sleep čekat jednu sekundu, simulovat práci, a pak voláním Release() přetížení metody uvolnit semafor. Při každém uvolnění semaforu se zobrazí počet předchozích semaforů. Zprávy konzoly sledují použití semaforu. Simulovaný pracovní interval se pro každé vlákno mírně prodloužil, aby byl výstup čitelnější.

#using <System.dll>
using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // A semaphore that simulates a limited resource pool.
   //
   static Semaphore^ _pool;

   // A padding interval to make the output more orderly.
   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 = gcnew Semaphore( 0,3 );
      
      // Create and start five numbered threads.
      //
      for ( int i = 1; i <= 5; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew 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( L"Main thread calls Release(3)." );
      _pool->Release( 3 );

      Console::WriteLine( L"Main thread exits." );
   }

private:
   static void Worker( Object^ num )
   {
      // Each worker thread begins by requesting the
      // semaphore.
      Console::WriteLine( L"Thread {0} begins and waits for the semaphore.", num );
      _pool->WaitOne();
      
      // A padding interval to make the output more orderly.
      int padding = Interlocked::Add( _padding, 100 );

      Console::WriteLine( L"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( L"Thread {0} releases the semaphore.", num );
      Console::WriteLine( L"Thread {0} previous semaphore count: {1}",
         num, _pool->Release() );
   }
};

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

Tento konstruktor inicializuje nepojmenovaný semafor. Všechna vlákna, která používají instanci takového semaforu, musí mít odkazy na instanci.

Pokud initialCount je menší než maximumCount, efekt je stejný, jako kdyby aktuální vlákno volal WaitOne (maximumCount minus initialCount) krát. Pokud nechcete rezervovat žádné položky pro vlákno, které vytváří semafor, použijte stejné číslo pro maximumCount a initialCount.

Viz také

• Spravovaná vlákna
• semafor

Semaphore(Int32, Int32, String)

Zdroj:

Semaphore.cs

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ě určuje název systémového semaforu objektu.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name);

public Semaphore (int initialCount, int maximumCount, string? name);

new System.Threading.Semaphore : int * int * string -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String)

Parametry

initialCount

Int32

Počáteční počet požadavků na semafor, které lze udělit současně.

maximumCount

Int32

Maximální počet požadavků na semafor, které lze udělit současně.

name

String

Název, pokud synchronizační objekt má být sdílen s jinými procesy; null nebo prázdný řetězec. V názvu se rozlišují velká a malá písmena. Znak zpětného lomítka (\) je vyhrazený a lze ho použít pouze k určení oboru názvů. Další informace o oborech názvů najdete v části poznámky. V závislosti na operačním systému můžou existovat další omezení názvu. Například v unixových operačních systémech musí být název po vyloučení oboru názvů platný název souboru.

Výjimky

ArgumentException

initialCount je větší než maximumCount.

-nebo-

Pouze rozhraní .NET Framework: name je delší než MAX_PATH (260 znaků).

ArgumentOutOfRangeException

maximumCount je menší než 1.

-nebo-

initialCount je menší než 0.

IOException

Formát name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém použít, například kvůli neznámé předponě nebo neplatným znakům. Všimněte si, že názvy a běžné předpony Global a Local rozlišují malá a velká písmena.

-nebo-

Došlo k jiné chybě. Vlastnost HResult může poskytnout další informace.

DirectoryNotFoundException

Pouze windows: name zadal neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

PathTooLongException

Je name příliš dlouhý. Omezení délky může záviset na operačním systému nebo konfiguraci.

UnauthorizedAccessException

Pojmenovaný semafor existuje a má zabezpečení řízení přístupu a uživatel nemá FullControl.

WaitHandleCannotBeOpenedException

Synchronizační objekt se zadaným name objektem nelze vytvořit. Objekt synchronizace jiného typu může mít stejný název.

Příklady

Následující příklad kódu ukazuje chování mezi procesy pojmenovaného semaforu. Příklad vytvoří pojmenovaný semafor s maximálním počtem pěti a počátečním počtem 5. Program provede tři volání WaitOne metody . Pokud tedy spustíte zkompilovaný příklad ze dvou oken příkazů, druhá kopie se zablokuje při třetím volání metody WaitOne. Uvolněte jednu nebo více položek v první kopii programu pro odblokování druhé.

#using <System.dll>
using namespace System;
using namespace System::Threading;

public ref class Example
{
public:
   static void main()
   {
      // Create a Semaphore object that represents the named
      // system semaphore "SemaphoreExample3". The semaphore has a
      // maximum count of five. The initial count is also five.
      // There is no point in using a smaller initial count,
      // because the initial count is not used if this program
      // doesn't create the named system semaphore, and with
      // this method overload there is no way to tell. Thus, this
      // program assumes that it is competing with other
      // programs for the semaphore.
      //
      Semaphore^ sem = gcnew Semaphore( 5,5,L"SemaphoreExample3" );
      
      // Attempt to enter the semaphore three times. If another
      // copy of this program is already running, only the first
      // two requests can be satisfied. The third blocks. Note
      // that in a real application, timeouts should be used
      // on the WaitOne calls, to avoid deadlocks.
      //
      sem->WaitOne();
      Console::WriteLine( L"Entered the semaphore once." );
      sem->WaitOne();
      Console::WriteLine( L"Entered the semaphore twice." );
      sem->WaitOne();
      Console::WriteLine( L"Entered the semaphore three times." );
      
      // The thread executing this program has entered the
      // semaphore three times. If a second copy of the program
      // is run, it will block until this program releases the
      // semaphore at least once.
      //
      Console::WriteLine( L"Enter the number of times to call Release." );
      int n;
      if ( Int32::TryParse( Console::ReadLine(),n ) )
      {
         sem->Release( n );
      }

      int remaining = 3 - n;
      if ( remaining > 0 )
      {
         Console::WriteLine( L"Press Enter to release the remaining "
         L"count ({0}) and exit the program.", remaining );
         Console::ReadLine();
         sem->Release( remaining );
      }
   }
};

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // Create a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample3". The semaphore has a
        // maximum count of five. The initial count is also five. 
        // There is no point in using a smaller initial count,
        // because the initial count is not used if this program
        // doesn't create the named system semaphore, and with 
        // this method overload there is no way to tell. Thus, this
        // program assumes that it is competing with other
        // programs for the semaphore.
        //
        Semaphore sem = new Semaphore(5, 5, "SemaphoreExample3");

        // Attempt to enter the semaphore three times. If another 
        // copy of this program is already running, only the first
        // two requests can be satisfied. The third blocks. Note 
        // that in a real application, timeouts should be used
        // on the WaitOne calls, to avoid deadlocks.
        //
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore once.");
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore twice.");
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore three times.");

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    }
}

Imports System.Threading

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' Create a Semaphore object that represents the named 
        ' system semaphore "SemaphoreExample3". The semaphore has a
        ' maximum count of five. The initial count is also five. 
        ' There is no point in using a smaller initial count,
        ' because the initial count is not used if this program
        ' doesn't create the named system semaphore, and with 
        ' this method overload there is no way to tell. Thus, this
        ' program assumes that it is competing with other
        ' programs for the semaphore.
        '
        Dim sem As New Semaphore(5, 5, "SemaphoreExample3")

        ' Attempt to enter the semaphore three times. If another 
        ' copy of this program is already running, only the first
        ' two requests can be satisfied. The third blocks. Note 
        ' that in a real application, timeouts should be used
        ' on the WaitOne calls, to avoid deadlocks.
        '
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore once.")
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore twice.")
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore three times.")

        ' The thread executing this program has entered the 
        ' semaphore three times. If a second copy of the program
        ' is run, it will block until this program releases the 
        ' semaphore at least once.
        '
        Console.WriteLine("Enter the number of times to call Release.")
        Dim n As Integer
        If Integer.TryParse(Console.ReadLine(), n) Then
            sem.Release(n)
        End If

        Dim remaining As Integer = 3 - n
        If (remaining) > 0 Then
            Console.WriteLine("Press Enter to release the remaining " _
                & "count ({0}) and exit the program.", remaining)
            Console.ReadLine()
            sem.Release(remaining)
        End If

    End Sub 
End Class

Poznámky

Tento konstruktor inicializuje Semaphore objekt, který představuje pojmenovaný systémový semafor. Můžete vytvořit více Semaphore objektů, které představují stejný pojmenovaný systémový semafor.

K name zadání oboru názvů může mít předponu Global\ nebo Local\ . Global Pokud je obor názvů zadaný, synchronizační objekt může být sdílen se všemi procesy v systému. Local Pokud je zadán obor názvů, což je také výchozí, pokud není zadán žádný obor názvů, synchronizační objekt může být sdílen s procesy ve stejné relaci. Ve Windows je relace přihlášení a služby obvykle běží v jiné neinteraktivní relaci. V unixových operačních systémech má každé prostředí svoji vlastní relaci. Objekty místní synchronizace relace mohou být vhodné pro synchronizaci mezi procesy se vztahem nadřazenosti a podřízenosti, kde se všechny spouští ve stejné relaci. Další informace o názvech synchronizačních objektů ve Windows najdete v tématu Názvy objektů.

name Pokud je zadán a objekt synchronizace požadovaného typu již existuje v oboru názvů, použije se existující synchronizační objekt. Pokud synchronizační objekt jiného typu již v oboru názvů existuje, WaitHandleCannotBeOpenedException vyvolá se objekt . V opačném případě se vytvoří nový synchronizační objekt.

Pokud pojmenovaný systémový semafor neexistuje, vytvoří se s počátečním a maximálním počtem zadaným a initialCountmaximumCount. Pokud pojmenovaný systémový semafor již existuje initialCount a maximumCount nejsou použity, i když neplatné hodnoty stále způsobují výjimky. Pokud potřebujete zjistit, zda byl vytvořen pojmenovaný systémový semafor, použijte místo toho přetížení konstruktoru Semaphore(Int32, Int32, String, Boolean) .

Důležité

Při použití tohoto přetížení konstruktoru je doporučeným postupem zadat stejné číslo pro initialCount a maximumCount. Pokud initialCount je menší než maximumCounta vytvoří se pojmenovaný systémový semafor, je efekt stejný, jako kdyby aktuální vlákno volal WaitOne (maximumCount minus initialCount) krát. S tímto přetížením konstruktoru však neexistuje žádný způsob, jak zjistit, zda byl vytvořen pojmenovaný systémový semafor.

Pokud zadáte null nebo prázdný řetězec pro name, vytvoří se místní semafor, jako byste volali Semaphore(Int32, Int32) konstruktor přetížení.

Vzhledem k tomu, že pojmenované semafory jsou viditelné v celém operačním systému, lze je použít ke koordinaci využití prostředků napříč hranicemi procesů.

Pokud chcete zjistit, jestli existuje pojmenovaný systémový semafor, použijte metodu OpenExisting . Metoda OpenExisting se pokusí otevřít existující pojmenovaný semafor a vyvolá výjimku, pokud systémový semafor neexistuje.

Upozornění

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

Viz také

• Spravovaná vlákna
• semafor

Semaphore(Int32, Int32, String, Boolean)

Zdroj:

Semaphore.cs

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ě určuje název objektu systémového semaforu a určuje proměnnou, která přijímá hodnotu označující, zda byl vytvořen nový systémový semafor.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew);

public Semaphore (int initialCount, int maximumCount, string? name, out bool createdNew);

new System.Threading.Semaphore : int * int * string * bool -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String, ByRef createdNew As Boolean)

Parametry

initialCount

Int32

Počáteční počet požadavků na semafor, které lze splnit souběžně.

maximumCount

Int32

Maximální počet požadavků na semafor, které lze současně splnit.

name

String

Název, pokud synchronizační objekt má být sdílen s jinými procesy; null nebo prázdný řetězec. V názvu se rozlišují velká a malá písmena. Znak zpětného lomítka (\) je vyhrazený a lze ho použít pouze k určení oboru názvů. Další informace o oborech názvů najdete v části s poznámkami. V závislosti na operačním systému můžou existovat další omezení pro název. Například v operačních systémech se systémem Unix musí být název po vyloučení oboru názvů platný název souboru.

createdNew

Boolean

Když tato metoda vrátí, obsahuje true , jestli byl vytvořen místní semafor (tj. pokud name je null nebo prázdný řetězec) nebo jestli byl vytvořen zadaný pojmenovaný systémový semafor; false pokud zadaný pojmenovaný systémový semafor již existuje. Tento parametr se předává neinicializovaný.

Výjimky

ArgumentException

initialCount je větší než maximumCount.

-nebo-

Pouze rozhraní .NET Framework: name je delší než MAX_PATH (260 znaků).

ArgumentOutOfRangeException

maximumCount je menší než 1.

-nebo-

initialCount je menší než 0.

IOException

Formát name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém umístit, jako je neznámá předpona nebo neplatné znaky. Všimněte si, že v názvu a běžných předponách Global a Local se rozlišují velká a malá písmena.

-nebo-

Došlo k jiné chybě. Vlastnost HResult může poskytnout další informace.

DirectoryNotFoundException

Pouze windows: name zadaný neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

PathTooLongException

Je name moc dlouhý. Omezení délky mohou záviset na operačním systému nebo konfiguraci.

UnauthorizedAccessException

Pojmenovaný semafor existuje a má zabezpečení řízení přístupu a uživatel nemá FullControl.

WaitHandleCannotBeOpenedException

Objekt synchronizace se zadaným name objektem nelze vytvořit. Objekt synchronizace jiného typu může mít stejný název.

Příklady

Následující příklad kódu ukazuje chování mezi procesy pojmenovaného semaforu. Příklad vytvoří pojmenovaný semafor s maximálním počtem pěti a počátečním počtem dvou. To znamená, že vyhrazuje tři položky pro vlákno, které volá konstruktor. Pokud createNew je false, program provede tři volání WaitOne metody . Pokud tedy spustíte zkompilovaný příklad ze dvou oken příkazů, druhá kopie se zablokuje při třetím volání metody WaitOne. Uvolněním jedné nebo více položek v první kopii programu odblokujte druhou.

#using <System.dll>
using namespace System;
using namespace System::Threading;

public ref class Example
{
public:
   static void main()
   {
      // The value of this variable is set by the semaphore
      // constructor. It is true if the named system semaphore was
      // created, and false if the named semaphore already existed.
      //
      bool semaphoreWasCreated;
      
      // Create a Semaphore object that represents the named
      // system semaphore "SemaphoreExample". The semaphore has a
      // maximum count of five, and an initial count of two. The
      // Boolean value that indicates creation of the underlying
      // system object is placed in semaphoreWasCreated.
      //
      Semaphore^ sem = gcnew Semaphore( 2,5,L"SemaphoreExample",
         semaphoreWasCreated );
      if ( semaphoreWasCreated )
      {
         // If the named system semaphore was created, its count is
         // set to the initial count requested in the constructor.
         // In effect, the current thread has entered the semaphore
         // three times.
         //
         Console::WriteLine( L"Entered the semaphore three times." );
      }
      else
      {
         // If the named system semaphore was not created,
         // attempt to enter it three times. If another copy of
         // this program is already running, only the first two
         // requests can be satisfied. The third blocks.
         //
         sem->WaitOne();
         Console::WriteLine( L"Entered the semaphore once." );
         sem->WaitOne();
         Console::WriteLine( L"Entered the semaphore twice." );
         sem->WaitOne();
         Console::WriteLine( L"Entered the semaphore three times." );
      }
      
      // The thread executing this program has entered the
      // semaphore three times. If a second copy of the program
      // is run, it will block until this program releases the
      // semaphore at least once.
      //
      Console::WriteLine( L"Enter the number of times to call Release." );
      int n;
      if ( Int32::TryParse( Console::ReadLine(), n ) )
      {
         sem->Release( n );
      }

      int remaining = 3 - n;
      if ( remaining > 0 )
      {
         Console::WriteLine( L"Press Enter to release the remaining "
         L"count ({0}) and exit the program.", remaining );
         Console::ReadLine();
         sem->Release( remaining );
      }
   }
};

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // The value of this variable is set by the semaphore
        // constructor. It is true if the named system semaphore was
        // created, and false if the named semaphore already existed.
        //
        bool semaphoreWasCreated;

        // Create a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample". The semaphore has a
        // maximum count of five, and an initial count of two. The
        // Boolean value that indicates creation of the underlying 
        // system object is placed in semaphoreWasCreated.
        //
        Semaphore sem = new Semaphore(2, 5, "SemaphoreExample", 
            out semaphoreWasCreated);

        if (semaphoreWasCreated)
        {
            // If the named system semaphore was created, its count is
            // set to the initial count requested in the constructor.
            // In effect, the current thread has entered the semaphore
            // three times.
            // 
            Console.WriteLine("Entered the semaphore three times.");
        }
        else
        {      
            // If the named system semaphore was not created,  
            // attempt to enter it three times. If another copy of
            // this program is already running, only the first two
            // requests can be satisfied. The third blocks.
            //
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore once.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore twice.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore three times.");
        }

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    } 
}

Imports System.Threading

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' The value of this variable is set by the semaphore
        ' constructor. It is True if the named system semaphore was
        ' created, and False if the named semaphore already existed.
        '
        Dim semaphoreWasCreated As Boolean

        ' Create a Semaphore object that represents the named 
        ' system semaphore "SemaphoreExample". The semaphore has a
        ' maximum count of five, and an initial count of two. The
        ' Boolean value that indicates creation of the underlying 
        ' system object is placed in semaphoreWasCreated.
        '
        Dim sem As New Semaphore(2, 5, "SemaphoreExample", _
            semaphoreWasCreated)

        If semaphoreWasCreated Then
            ' If the named system semaphore was created, its count is
            ' set to the initial count requested in the constructor.
            ' In effect, the current thread has entered the semaphore
            ' three times.
            ' 
            Console.WriteLine("Entered the semaphore three times.")
        Else
            ' If the named system semaphore was not created,  
            ' attempt to enter it three times. If another copy of
            ' this program is already running, only the first two
            ' requests can be satisfied. The third blocks.
            '
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore once.")
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore twice.")
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore three times.")
        End If

        ' The thread executing this program has entered the 
        ' semaphore three times. If a second copy of the program
        ' is run, it will block until this program releases the 
        ' semaphore at least once.
        '
        Console.WriteLine("Enter the number of times to call Release.")
        Dim n As Integer
        If Integer.TryParse(Console.ReadLine(), n) Then
            sem.Release(n)
        End If

        Dim remaining As Integer = 3 - n
        If (remaining) > 0 Then
            Console.WriteLine("Press Enter to release the remaining " _
                & "count ({0}) and exit the program.", remaining)
            Console.ReadLine()
            sem.Release(remaining)
        End If

    End Sub 
End Class

Poznámky

Předpona nameGlobal\ může mít předponu nebo Local\ k určení oboru názvů. Při zadání Global oboru názvů může být synchronizační objekt sdílen s libovolnými procesy v systému. Local Pokud je zadán obor názvů, což je také výchozí, pokud není zadán žádný obor názvů, synchronizační objekt může být sdílen s procesy ve stejné relaci. V systému Windows je relace přihlášení a služby obvykle běží v jiné neinteraktivní relaci. V unixových operačních systémech má každé prostředí svoji vlastní relaci. Objekty místní synchronizace relace mohou být vhodné pro synchronizaci mezi procesy s nadřazeným a podřízeným vztahem, kde se všechny spouští ve stejné relaci. Další informace o názvech objektů synchronizace ve Windows najdete v tématu Názvy objektů.

name Pokud je zadán objekt synchronizace požadovaného typu již existuje v oboru názvů, použije se existující objekt synchronizace. Pokud v oboru názvů již existuje objekt synchronizace jiného typu, WaitHandleCannotBeOpenedException vyvolá se objekt . V opačném případě se vytvoří nový objekt synchronizace.

Tento konstruktor inicializuje Semaphore objekt, který představuje pojmenovaný semafor systému. Můžete vytvořit více Semaphore objektů, které představují stejný pojmenovaný systémový semafor.

Pokud pojmenovaný systémový semafor neexistuje, vytvoří se s počátečním a maximálním počtem zadaným pomocí initialCount a maximumCount. Pokud pojmenovaný systémový semafor již existuje initialCount a maximumCount nepoužívá se, i když neplatné hodnoty stále způsobují výjimky. Slouží createdNew k určení, zda byl vytvořen semafor systému.

Pokud initialCount je menší než maximumCount, a createdNew je true, efekt je stejný, jako kdyby aktuální vlákno volal WaitOne (maximumCount minus initialCount) krát.

Pokud zadáte null nebo prázdný řetězec pro name, vytvoří se místní semafor, jako byste volali přetížení konstruktoru Semaphore(Int32, Int32) . V tomto případě createdNew je vždy true.

Vzhledem k tomu, že pojmenované semafory jsou viditelné v celém operačním systému, je možné je použít ke koordinaci využití prostředků napříč hranicemi procesů.

Upozornění

Ve výchozím nastavení není pojmenovaný semafor omezen na uživatele, který ho vytvořil. Jiní uživatelé mohou být schopni semafor otevřít a používat, včetně narušení semaforu tím, že semafor získá vícekrát a neuvolní ho. Pokud chcete omezit přístup na konkrétní uživatele, můžete při vytváření pojmenovaného semaforu použít přetížení konstruktoru nebo SemaphoreAcl předat SemaphoreSecurity objekt. Vyhněte se používání pojmenovaných semaforů bez omezení přístupu v systémech, které můžou mít nedůvěryhodné uživatele s kódem.

Viz také

• Spravované vlákno
• semafor