Semaphore Třída

Definice

public ref class Semaphore sealed : System::Threading::WaitHandle

public sealed class Semaphore : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(false)]
public sealed class Semaphore : System.Threading.WaitHandle

type Semaphore = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(false)>]
type Semaphore = class
    inherit WaitHandle

Public NotInheritable Class Semaphore
Inherits WaitHandle

Dědičnost

Object

WaitHandle

Semaphore

Dědičnost

Object

MarshalByRefObject

WaitHandle

Semaphore

Atributy

ComVisibleAttribute

Příklady

Následující příklad kódu 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

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

Počet na semaforu se sníží pokaždé, když vlákno vstoupí do semaforu, a zvýší se, když vlákno uvolní semafor. Pokud je počet nulový, následné požadavky se zablokují, dokud ostatní vlákna semafor nespustí. Když všechna vlákna uvolní semafor, počet je na maximální hodnotě zadané při vytvoření semaforu.

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

Vlákno může vstoupit do semaforu vícekrát 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 uvolně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 semafor příliš mnohokrát. Předpokládejme například, že semafor má maximální počet dvou a toto vlákno A a vlákno B vstoupí do semaforu. Pokud programovací chyba ve vlákně B způsobí, že se zavolá Release dvakrát, obě volání budou úspěšná. Počet na semaforu je plný a když vlákno A nakonec zavolá Release, SemaphoreFullException vyvolá se .

Semafory jsou dvou typů: místní semafory 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émový semafor, a můžete použít metodu OpenExisting k otevření existující pojmenované systémové semafor.

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

Konstruktory

Pole

Vlastnosti

Metody

Explicitní implementace rozhraní

Metody rozšíření

Platí pro

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é vlákno
• semafor