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 s určení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 objektu semaforu.
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 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.

Semaphore(Int32, Int32)

Zdroj:

Semaphore.cs

Inicializuje novou instanci Semaphore třídy s určení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 souběžně.

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 ke zvýšení počtu semaforů na maximum, což umožňuje tři vlákna vstoupit do semaforu. Každé vlákno používá metodu Thread.Sleep k čekání na jednu sekundu, k simulaci práce, a pak voláním Release() přetížení metody uvolnit semafor. Při každém uvolnění semaforu se zobrazí předchozí počet semaforů. Zprávy konzoly sledují použití semaforu. Simulovaný pracovní interval se pro každé vlákno mírně zvýší, 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ákno
• 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 objektu semaforu.

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 souběžně.

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 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.

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. V příkladu se vytvoří pojmenovaný semafor s maximálním počtem pěti a počátečním počtem pěti. Program provede tři volání WaitOne metody. Pokud tedy zkompilovaný příklad spustíte ze dvou oken příkazů, druhá kopie se zablokuje při třetím volání příkazu 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()
   {
      // 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ý semafor systému. Můžete vytvořit více Semaphore objektů, které představují stejný pojmenovaný systémový semafor.

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.

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. Pokud potřebujete zjistit, zda byl vytvořen pojmenovaný semafor systému, 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 se doporučuje 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 způsob, jak zjistit, zda byl vytvořen pojmenovaný semafor systému.

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) .

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ů.

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

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

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 si 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 zkompilovaný příklad spustíte ze dvou oken příkazů, druhá kopie se zablokuje při třetím volání příkazu 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