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

Dikkat

Varsayılan olarak, adlandırılmış bir semafor onu oluşturan kullanıcıyla sınırlı değildir. Diğer kullanıcılar semaforu birden çok kez alarak ve serbest bırakmayarak semafora müdahale etmek de dahil olmak üzere semaforu açabilir ve kullanabilir. Erişimi belirli kullanıcılarla kısıtlamak için bir oluşturucu aşırı yüklemesi kullanabilir veya SemaphoreAcl adlandırılmış semaforu oluştururken bir SemaphoreSecurity geçirebilirsiniz. Kod çalıştıran güvenilmeyen kullanıcıların olabileceği sistemlerde erişim kısıtlamaları olmadan adlandırılmış semafor kullanmaktan kaçının.

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)

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

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 bir 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 semaforu 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 tutamaçlarından herhangi biri sinyal almadan önce bir WaitAny(WaitHandle[], Int32, Boolean) işlemin zaman aşımına uğradı olduğunu gösterir. Bu alan sabittir.

(Devralındığı yer: WaitHandle)

Özellikler

Handle
Geçersiz.
Geçersiz.

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 WaitHandletarafından tutulan tüm kaynakları serbest bırakır.

(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ındığında, tarafından WaitHandlekullanılan yönetilmeyen kaynakları serbest bırakır 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()
Geçersiz.

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()
Geçersiz.

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 adlandırılmış semaforu ,zaten varsa, istenen güvenlik erişimiyle açar ve işlemin başarılı olup olmadığını belirten bir değer döndürür.

WaitOne()

Geçerli iş parçacığını, geçerli WaitHandle bir sinyal alıncaya kadar engeller.

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

Geçerli iş parçacığı, milisaniye WaitHandle cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli iş parçacığını engeller.

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

Geçerli iş parçacığını, zaman WaitHandle aralığını belirtmek ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir sinyal alana kadar geçerli iş parçacığını engeller.

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

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

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

Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için kullanarak TimeSpan ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtir.

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