Semaphore Sınıf

Tanım

Aynı anda bir kaynağa veya kaynak havuzuna erişebilen iş parçacıklarının sayısını sınırlandırır.Limits the number of threads that can access a resource or pool of resources concurrently.

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 üç sayısı ve başlangıç sayısı sıfır olan bir semafor oluşturur.The following code example creates a semaphore with a maximum count of three and an initial count of zero. Örnek beş iş parçacığı başlatır ve bu da semafor beklemeyi engeller.The example starts five threads, which block waiting for the semaphore. Ana iş parçacığı, Release(Int32) semafor sayısını maksimum olarak artırmak için yöntem aşırı yüklemesini kullanır, bu da üç iş parçacığına semaforu girmelerini sağlar.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Her iş parçacığı, Thread.Sleep bir saniye beklemek, çalışmanın benzetimini yapmak için yöntemini kullanır ve sonra Release() semaforu serbest bırakmak için yöntem aşırı yüklemesini çağırır.Each thread uses the Thread.Sleep method to wait for one second, to simulate work, and then calls the Release() method overload to release the semaphore. Semaforun her yayımlanışında, önceki semafor sayısı görüntülenir.Each time the semaphore is released, the previous semaphore count is displayed. Konsol iletileri semafor kullanımını izler.Console messages track semaphore use. Daha kolay okunması için, her iş parçacığı için benzetimli çalışma aralığı biraz artar.The simulated work interval is increased slightly for each thread, to make the output easier to read.

#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(0, 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(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

SemaphoreKaynak havuzuna erişimi denetlemek için sınıfını kullanın.Use the Semaphore class to control access to a pool of resources. İş parçacıkları, sınıfından devralınan yöntemini çağırarak semaforu girer WaitOne WaitHandle ve yöntemi çağırarak semaforu serbest bırakabilir Release .Threads enter the semaphore by calling the WaitOne method, which is inherited from the WaitHandle class, and release the semaphore by calling the Release method.

Bir semafor üzerinde bulunan sayı, her bir iş parçacığı semafora girdiğinde azaltılır ve bir iş parçacığı semaforu bıraktığında artırılır.The count on a semaphore is decremented each time a thread enters the semaphore, and incremented when a thread releases the semaphore. Sayı sıfır olduğunda, sonraki istekler diğer iş parçacıkları semaforu serbest bırakana kadar engeller.When the count is zero, subsequent requests block until other threads release the semaphore. Tüm iş parçacıkları semaforu serbest bırakımışsa, sayı semafor oluşturulduğunda belirtilen en büyük değerde olur.When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created.

Engellenen iş parçacıklarının semaforu girmesi için FıFO veya LıFO gibi garantili bir sıra yoktur.There is no guaranteed order, such as FIFO or LIFO, in which blocked threads enter the semaphore.

Bir iş parçacığı, yöntemi tekrar tekrar çağırarak semaforu birden çok kez girebilir WaitOne .A thread can enter the semaphore multiple times, by calling the WaitOne method repeatedly. Bu girdilerin bazılarını veya tümünü yayınlamak için, iş parçacığı parametresiz Release() yöntem aşırı yüklemesini birden çok kez çağırabilir veya Release(Int32) yayımlanacak girdi sayısını belirten yöntem aşırı yüklemesini çağırabilir.To release some or all of these entries, the thread can call the parameterless Release() method overload multiple times, or it can call the Release(Int32) method overload that specifies the number of entries to be released.

SemaphoreSınıfı, veya çağrılarında iş parçacığı kimliğini zorlamaz WaitOne Release .The Semaphore class does not enforce thread identity on calls to WaitOne or Release. İş parçacıklarının semaforu çok fazla kez serbest bırakmadığından emin olmak programcı sorumluluğundadır.It is the programmer's responsibility to ensure that threads do not release the semaphore too many times. Örneğin, bir semaforun en fazla iki sayısına sahip olduğunu ve A iş parçacığı A ve iş parçacığı B 'nin her ikisi de semaforu girmelerini sağladığını varsayalım.For example, suppose a semaphore has a maximum count of two, and that thread A and thread B both enter the semaphore. B iş parçacığında bir programlama hatası, iki kez çağrı yapmasına neden olursa Release her iki çağrı de başarılı olur.If a programming error in thread B causes it to call Release twice, both calls succeed. Semaforda bulunan sayı dolu ve iş parçacığı sonunda çağrı yaptığı zaman Release bir SemaphoreFullException atılır.The count on the semaphore is full, and when thread A eventually calls Release, a SemaphoreFullException is thrown.

Semaforlar iki türtür: yerel Semaforlar ve adlandırılmış sistem semaforları.Semaphores are of two types: local semaphores and named system semaphores. Bir Semaphore adı kabul eden bir Oluşturucu kullanarak bir nesne oluşturursanız, bu ad bir işletim sistemi semaforuyla ilişkilendirilir.If you create a Semaphore object using a constructor that accepts a name, it is associated with an operating-system semaphore of that name. Adlandırılmış sistem semaforları işletim sisteminin tamamında görünür ve işlem etkinliklerini eşzamanlı hale getirmek için kullanılabilir.Named system semaphores are visible throughout the operating system, and can be used to synchronize the activities of processes. SemaphoreAynı adlı sistem semaforu temsil eden birden çok nesne oluşturabilir ve bu OpenExisting yöntemi kullanarak mevcut bir adlandırılmış sistem semaforu açabilirsiniz.You can create multiple Semaphore objects that represent the same named system semaphore, and you can use the OpenExisting method to open an existing named system semaphore.

Yerel bir semafor yalnızca işlem dahilinde bulunur.A local semaphore exists only within your process. Bu, işleinizdeki yerel nesneye yönelik bir başvuruya sahip herhangi bir iş parçacığı tarafından kullanılabilir Semaphore .It can be used by any thread in your process that has a reference to the local Semaphore object. Her Semaphore nesne ayrı bir yerel semaforu.Each Semaphore object is a separate local semaphore.

Oluşturucular

Semaphore(Int32, Int32)

Semaphoreİlk giriş sayısını ve en fazla eşzamanlı giriş sayısını belirterek, sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries.

Semaphore(Int32, Int32, String)

Semaphoreİlk giriş sayısını ve en fazla eşzamanlı giriş sayısını belirterek ve isteğe bağlı olarak bir sistem semaforu nesnesinin adını belirterek, sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, and optionally specifying the name of a system semaphore object.

Semaphore(Int32, Int32, String, Boolean)

Semaphoreİlk giriş sayısını ve en fazla eşzamanlı giriş sayısını belirterek, isteğe bağlı olarak bir sistem semaforu nesnesinin adını belirterek ve yeni bir sistem semaforun oluşturulup oluşturulmayacağını gösteren bir değer alan bir değişken belirterek, sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, and specifying a variable that receives a value indicating whether a new system semaphore was created.

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

Semaphoreİlk giriş sayısını ve en fazla eşzamanlı giriş sayısını belirterek, isteğe bağlı olarak bir sistem semaforu nesnesi adı ve yeni bir sistem semaforun oluşturulup oluşturulmayacağını belirten bir değer alan bir değişken belirterek ve sistem semaforu için güvenlik erişimi denetimi belirterek, sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, specifying a variable that receives a value indicating whether a new system semaphore was created, and specifying security access control for the system semaphore.

Alanlar

WaitTimeout

WaitAny(WaitHandle[], Int32, Boolean)Herhangi bir bekleme tanıtıcıdan önce bir işlemin zaman aşımına uğradığını gösterir.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Bu alan sabittir.This field is constant.

(Devralındığı yer: WaitHandle)

Özellikler

Handle
Kullanımdan kalktı.

Yerel işletim sistemi tanıtıcısını alır veya ayarlar.Gets or sets the native operating system handle.

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

Yerel işletim sistemi tanıtıcısını alır veya ayarlar.Gets or sets the native operating system handle.

(Devralındığı yer: WaitHandle)

Yöntemler

Close()

Geçerli tarafından tutulan tüm kaynakları serbest bırakır WaitHandle .Releases all resources held by the current 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 bilgileri içeren bir nesne oluşturur.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(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.Releases all resources used by the current instance of the WaitHandle class.

(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.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

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

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

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

Adlandırılmış sistem semaforu için erişim denetimi güvenliğini alır.Gets the access control security for a named system semaphore.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

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

Bu örnek için ömür ilkesini denetleyen geçerli ömür hizmeti nesnesini alır.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

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

TypeGeçerli örneği alır.Gets the Type of the current instance.

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

Bu örnek için ömür ilkesini denetlemek üzere bir ömür hizmeti nesnesi alır.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

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

Geçerli nesnenin basit bir kopyasını oluşturur MarshalByRefObject .Creates a shallow copy of the current MarshalByRefObject object.

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

Zaten varsa belirtilen adlandırılmış semaforu açar.Opens the specified named semaphore, if it already exists.

OpenExisting(String, SemaphoreRights)

Zaten varsa, istenen güvenlik erişimiyle birlikte belirtilen adlandırılmış semaforu açar.Opens the specified named semaphore, if it already exists, with the desired security access.

Release()

Semafor çıkar ve önceki sayıyı döndürür.Exits the semaphore and returns the previous count.

Release(Int32)

Semafor belirtilen sayıda kez çıkar ve önceki sayıyı döndürür.Exits the semaphore a specified number of times and returns the previous count.

SetAccessControl(SemaphoreSecurity)

Adlandırılmış sistem semaforu için erişim denetimi güvenliğini ayarlar.Sets the access control security for a named system semaphore.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

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

Zaten varsa belirtilen adlandırılmış semaforu açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, SemaphoreRights, Semaphore)

Zaten varsa, istenen güvenlik erişimiyle birlikte belirtilen adlandırılmış semaforu açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.Opens the specified named semaphore, if it already exists, with the desired security access, and returns a value that indicates whether the operation succeeded.

WaitOne()

Geçerli bir sinyal alana kadar geçerli iş parçacığını engeller WaitHandle .Blocks the current thread until the current WaitHandle receives a signal.

(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(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.Releases all resources used by the WaitHandle.

(Devralındığı yer: WaitHandle)

Uzantı Metotları

GetAccessControl(Semaphore)

Belirtilen için güvenlik tanımlayıcılarını döndürür semaphore .Returns the security descriptors for the specified semaphore.

SetAccessControl(Semaphore, SemaphoreSecurity)

Belirtilen semafor için güvenlik tanımlayıcılarını ayarlar.Sets the security descriptors for the specified semaphore.

GetSafeWaitHandle(WaitHandle)

Yerel bir işletim sistemi bekleme tutamacı için güvenli tanıtıcıyı alır.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Yerel işletim sistemi bekleme tutamacı için güvenli bir tanıtıcı ayarlar.Sets a safe handle for a native operating system wait handle.

Şunlara uygulanır

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

Bu güvenli iş parçacığı türüdür.This type is thread safe.