Semaphore Sınıf

Tanım

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

Devralma

Object

WaitHandle

Semaphore

Devralma

Object

MarshalByRefObject

WaitHandle

Semaphore

Öznitelikler

ComVisibleAttribute

Örnekler

Aşağıdaki kod örneği, en fazla üç ve ilk sayısı sıfır olan bir semafor oluşturur. Örnek, semafor beklemeyi engelleyen beş iş parçacığı başlatır. Ana iş parçacığı, semafor sayısını maksimuma yükseltmek için yöntem aşırı yüklemesini kullanarak Release(Int32) üç iş parçacığının semafora girmesine izin verir. Her iş parçacığı, çalışmanın benzetimini Thread.Sleep yapmak için bir saniye beklemek için yöntemini kullanır ve ardından semaforu Release() serbest bırakmak için yöntem aşırı yüklemesini çağırır. Semafor her serbest bırakıldığında, önceki semafor sayısı görüntülenir. Konsol iletileri semafor kullanımını izler. Simülasyon çalışma aralığı, çıkışın okunmasını kolaylaştırmak için her iş parçacığı için biraz artırılır.

#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

Açıklamalar

Bir kaynak havuzuna Semaphore erişimi denetlemek için sınıfını kullanın. İş parçacıkları, sınıfından devralınan WaitOneWaitHandle yöntemini çağırarak semaforu girer ve yöntemini çağırarak semaforu Release serbest bırakır.

Bir semafor üzerindeki sayı, bir iş parçacığı semafora her girdiğinde azalmış ve bir iş parçacığı semaforu serbest bıraktığında artırılır. Sayı sıfır olduğunda, izleyen istekler diğer iş parçacıkları semaforu serbest bırakana kadar engeller. Tüm iş parçacıkları semaforu serbest bırakıldığında, sayı semafor oluşturulduğunda belirtilen en yüksek değerde olur.

Engellenen iş parçacıklarının semafora girdiği FIFO veya LIFO gibi garantili bir düzen yoktur.

Bir iş parçacığı, yöntemi tekrar tekrar çağırarak semaforu WaitOne birden çok kez girebilir. Bu girdilerin bazılarını veya tümünü serbest bırakmak için, iş parçacığı parametresiz Release() yöntem aşırı yüklemesini birden çok kez çağırabilir veya serbest bırakılacak girdi sayısını belirten yöntem aşırı yüklemesini çağırabilir Release(Int32) .

Semaphore sınıfı, veya Releaseçağrılarında WaitOne iş parçacığı kimliğini zorlamaz. İş parçacıklarının semaforu çok fazla kez bırakmadığından emin olmak programcının sorumluluğundadır. Örneğin, bir semaforun en fazla iki sayının olduğunu ve A ve B iş parçacığının her ikisinin de semafora girdiğini varsayalım. B iş parçacığındaki bir programlama hatası iki kez çağırmasına Release neden olursa, her iki çağrı da başarılı olur. Semafordaki sayı dolu ve A iş parçacığı sonunda çağırdığında Releasea SemaphoreFullException oluşturulur.

Semaforlar iki türdendir: yerel semaforlar ve adlandırılmış sistem semaforları. Bir adı kabul eden bir oluşturucu kullanarak bir Semaphore nesne oluşturursanız, bu adın işletim sistemi semaforuyla ilişkilendirilir. Adlandırılmış sistem semaforları işletim sistemi genelinde görünür ve işlemlerin etkinliklerini eşitlemek için kullanılabilir. Aynı adlandırılmış sistem semaforunu temsil eden birden çok Semaphore nesne oluşturabilir ve yöntemini kullanarak mevcut adlandırılmış sistem semaforunu OpenExisting açabilirsiniz.

Yerel bir semafor yalnızca sizin sürecinizde var. Yerel nesneye başvurusu Semaphore olan işleminizdeki herhangi bir iş parçacığı tarafından kullanılabilir. Her Semaphore nesne ayrı bir yerel semafordur.

Oluşturucular

Alanlar

Özellikler

Yöntemler

Belirtik Arabirim Kullanımları

Uzantı Metotları

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu güvenli iş parçacığı türüdür.

Ayrıca bkz.

• Yönetilen İş Parçacığı Oluşturma
• Semafor