Semaphore Sınıf

Tanım

Bir kaynağa veya kaynak havuzuna eşzamanlı olarak erişebilecek iş parçacığı sayısını sınırlar.

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
Semaphore
Devralma
Öznitelikler

Örnekler

Aşağıdaki kod örneği, en fazla üç ve ilk sayısı sıfır olan bir semafor oluşturur. Örnek, semaforu bekleyen beş iş parçacığını 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ığı, bir saniye beklemek, işin benzetimini yapmak için yöntemini kullanır Thread.Sleep ve ardından semaforu serbest bırakmak için yöntem aşırı yüklemesini çağırır Release() . Semafor her serbest bırakıldığında, önceki semafor sayısı görüntülenir. Konsol iletileri semafor kullanımını izler. Çıkışın daha kolay okunmasını sağlamak için simülasyon çalışma aralığı 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 WaitOne WaitHandle 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, diğer iş parçacıkları semaforu serbest bırakana kadar izleyen istekler 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 sıra yoktur.

Bir iş parçacığı, yöntemini 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) .

sınıfı, Semaphore veya Releaseçağrılarında WaitOne iş parçacığı kimliğini zorlamaz. İş parçacıklarının semaforu çok fazla serbest bırakmamasını sağlamak programcının sorumluluğundadır. Örneğin, bir semaforun en fazla iki sayısına sahip olduğunu ve A ve B iş parçacığının 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. Semafor üzerindeki sayı dolu ve A iş parçacığı sonunda çağırdığında Releasebir SemaphoreFullException oluşturulur.

Semaforlar iki türdendir: yerel semaforlar ve adlandırılmış sistem semaforları. Bir adı kabul eden bir Semaphore oluşturucu kullanarak bir 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 mevcut bir adlandırılmış sistem semaforunu OpenExisting açmak için yöntemini kullanabilirsiniz.

Yerel bir semafor yalnızca sizin işleminizde 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

Semaphore(Int32, Int32)

İlk girdi sayısını ve eşzamanlı girdi sayısı üst sınırını belirterek sınıfının yeni bir örneğini Semaphore başlatır.

Semaphore(Int32, Int32, String)

sınıfının yeni bir örneğini Semaphore başlatır, ilk girdi sayısını ve eşzamanlı girdi sayısı üst sınırını belirtir ve isteğe bağlı olarak sistem semafor nesnesinin adını belirtir.

Semaphore(Int32, Int32, String, Boolean)

sınıfının yeni bir örneğini Semaphore başlatır, ilk girdi sayısını ve en fazla eşzamanlı girdi sayısını belirtir, isteğe bağlı olarak sistem semafor nesnesinin adını belirtir ve yeni bir sistem semaforunun oluşturulup oluşturulmadığını belirten bir değer alan bir değişken belirtir.

Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)

sınıfının yeni bir örneğini Semaphore başlatır, ilk girdi sayısını ve en fazla eşzamanlı girdi sayısını belirtir, isteğe bağlı olarak sistem semafor nesnesinin adını belirtir, yeni bir sistem semaforunun oluşturulup oluşturulmadığını belirten bir değer alan bir değişken belirtir ve sistem semaforu için güvenlik erişim denetimi belirtir.

Alanlar

WaitTimeout

Bekleme WaitAny(WaitHandle[], Int32, Boolean) tutamaçlarının herhangi biri sinyal vermeden önce bir işlem zamanlandı olduğunu gösterir. Bu alan sabittir.

(Devralındığı yer: WaitHandle)

Özellikler

Handle
Kullanımdan kalktı.
Kullanımdan kalktı.

Yerel işletim sistemi tanıtıcısını alır veya ayarlar.

(Devralındığı yer: WaitHandle)
SafeWaitHandle

Yerel işletim sistemi tanıtıcısını alır veya ayarlar.

(Devralındığı yer: WaitHandle)

Yöntemler

Close()

Geçerli tarafından tutulan tüm kaynakları serbest bırakır WaitHandle .

(Devralındığı yer: WaitHandle)
CreateObjRef(Type)

Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur.

(Devralındığı yer: MarshalByRefObject)
Dispose()

WaitHandle sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır.

(Devralındığı yer: WaitHandle)
Dispose(Boolean)

Türetilmiş bir sınıfta geçersiz kılınırsa, tarafından kullanılan yönetilmeyen kaynakları yayınlar WaitHandle ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır.

(Devralındığı yer: WaitHandle)
Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.

(Devralındığı yer: Object)
GetAccessControl()

Adlandırılmış sistem semaforu için erişim denetimi güvenliğini alır.

GetHashCode()

Varsayılan karma işlevi işlevi görür.

(Devralındığı yer: Object)
GetLifetimeService()
Kullanımdan kalktı.

Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır.

(Devralındığı yer: MarshalByRefObject)
GetType()

Type Geçerli örneğini alır.

(Devralındığı yer: Object)
InitializeLifetimeService()
Kullanımdan kalktı.

Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır.

(Devralındığı yer: MarshalByRefObject)
MemberwiseClone()

Geçerli Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
MemberwiseClone(Boolean)

Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur.

(Devralındığı yer: MarshalByRefObject)
OpenExisting(String)

Zaten varsa belirtilen adlandırılmış semaforu açar.

OpenExisting(String, SemaphoreRights)

Belirtilen adlandırılmış semaforu , varsa, istenen güvenlik erişimiyle açar.

Release()

Semafordan çıkar ve önceki sayıyı döndürür.

Release(Int32)

Semafordan belirtilen sayıda çıkar ve önceki sayıyı döndürür.

SetAccessControl(SemaphoreSecurity)

Adlandırılmış sistem semaforu için erişim denetimi güvenliğini ayarlar.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.

(Devralındığı yer: Object)
TryOpenExisting(String, Semaphore)

Belirtilen adlandırılmış semaforu zaten varsa açar ve işlemin başarılı olup olmadığını belirten bir değer döndürür.

TryOpenExisting(String, SemaphoreRights, Semaphore)

Belirtilen adlı semaforu , zaten varsa, istenen güvenlik erişimiyle açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.

WaitOne()

Geçerli sinyal alana kadar geçerli WaitHandle iş parçacığını engeller.

(Devralındığı yer: WaitHandle)
WaitOne(Int32)

Geçerli iş parçacığını, geçerli bir sinyal alana kadar engeller WaitHandle ve zaman aralığını milisaniye olarak belirtmek için 32 bitlik işaretli bir tamsayı kullanın.

(Devralındığı yer: WaitHandle)
WaitOne(Int32, Boolean)

Geçerli bir sinyal alana kadar geçerli iş parçacığını engeller WaitHandle , zaman aralığını belirtmek için 32 bitlik işaretli bir tamsayı kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek.

(Devralındığı yer: WaitHandle)
WaitOne(TimeSpan)

Geçerli örnek bir sinyal alıncaya kadar geçerli iş parçacığını engeller ve TimeSpan zaman aralığını belirtmek için bir kullanın.

(Devralındığı yer: WaitHandle)
WaitOne(TimeSpan, Boolean)

Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller, TimeSpan zaman aralığını belirtmek için bir kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek.

(Devralındığı yer: WaitHandle)

Belirtik Arabirim Kullanımları

IDisposable.Dispose()

Bu API, ürün altyapısını destekler ve doğrudan kodunuzdan kullanıma yönelik değildir.

WaitHandle tarafından kullanılan tüm kaynakları serbest bırakır.

(Devralındığı yer: WaitHandle)

Uzantı Metotları

GetAccessControl(Semaphore)

Belirtilen semaphoreiçin güvenlik tanımlayıcılarını döndürür.

SetAccessControl(Semaphore, SemaphoreSecurity)

Belirtilen semafor için güvenlik tanımlayıcılarını ayarlar.

GetSafeWaitHandle(WaitHandle)

Yerel işletim sistemi bekleme tutamacını güvenli tutamacını alır.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Yerel işletim sistemi bekleme tutamacı için güvenli bir tanıtıcı ayarlar.

Şunlara uygulanır

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

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

Ayrıca bkz.