Semaphore Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Threading.dll

Kaynak:

Semaphore.cs

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

type Semaphore = class
    inherit WaitHandle

Public NotInheritable Class Semaphore
Inherits WaitHandle

Devralma

Object

MarshalByRefObject

WaitHandle

Semaphore

Ö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 girmesini sağlar. Her iş parçacığı, çalışmayı simüle etmek için bir saniye beklemek 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. 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;
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ıraktığı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ö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ı veya SemaphoreReleaseçağrılarında WaitOne iş parçacığı kimliğini zorlamaz. İş parçacıklarının semaforu çok fazla serbest bırakmadığından emin olmak programcının sorumluluğundadır. Örneğin, bir semaforun en fazla iki sayısı 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. Semafordaki sayı dolu ve A iş parçacığı sonunda Release'ı çağırdığında bir SemaphoreFullException fırlatılır.

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. İşleminizde yerel Semaphore nesnesine referansı olan herhangi bir iş parçacığı tarafından kullanılabilir. Her Semaphore nesne ayrı bir yerel semafordur.

Caution

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ılara kısıtlamak için bir oluşturucu aşırı yüklemesini kullanabilir veya SemaphoreAcl adlandırılmış semaforu oluştururken bir SemaphoreSecurity geçirebilirsiniz. Kod çalıştıran güvenilmeyen kullanıcılara sahip olabilecek sistemlerde erişim kısıtlamaları olmadan adlandırılmış semafor kullanmaktan kaçının.

Oluşturucular

Name	Description
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, NamedWaitHandleOptions, 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ı ve kullanıcı kapsamı ve oturum kapsamı erişimini ayarlama seçeneklerini 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, NamedWaitHandleOptions)	İlk girdi sayısını ve en fazla eşzamanlı girdi sayısını belirterek ve isteğe bağlı olarak kullanıcı kapsamı ve oturum kapsamı erişimini ayarlamak için sistem semafor nesnesinin adını ve seçeneklerini belirterek sınıfı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)	İlk girdi sayısını ve en fazla eşzamanlı girdi sayısını belirterek sınıfının yeni bir örneğini Semaphore başlatır.

Alanlar

Name	Description
WaitTimeout	Bekleme tutamaçlarından herhangi biri işaretlenmeden önce bir WaitAny(WaitHandle[], Int32, Boolean) işlemin zaman aşımına uğramasını gösterir. Bu alan sabittir. (Devralındığı yer: WaitHandle)

Özellikler

Name	Description
Handle	Geçersiz. Yerel işletim sistemi tutamacını alır veya ayarlar. (Devralındığı yer: WaitHandle)
SafeWaitHandle	Yerel işletim sistemi tutamacını alır veya ayarlar. (Devralındığı yer: WaitHandle)

Yöntemler

Name	Description
Close()	Geçerli WaitHandletarafından tutulan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Dispose()	Sınıfın geçerli örneği WaitHandle 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)
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()	Geçerli örneğin Type 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 Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Belirtilen adlandırılmış semaforu zaten varsa açar. Seçenekler yalnızca geçerli kullanıcıya ayarlanırsa, nesnenin erişim denetimleri çağıran kullanıcı için doğrulanır.
OpenExisting(String)	Belirtilen adlandırılmış semaforu zaten varsa 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.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
TryOpenExisting(String, NamedWaitHandleOptions, Semaphore)	Belirtilen adlandırılmış semaforu zaten varsa açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür. Seçenekler yalnızca geçerli kullanıcıya ayarlanırsa, nesnenin erişim denetimleri çağıran kullanıcı için doğrulanır.
TryOpenExisting(String, Semaphore)	Belirtilen adlandırılmış semaforu zaten varsa açar ve işlemin başarılı olup olmadığını gösteren 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, Boolean)	Geçerli iş parçacığını, zaman aralığını belirtmek ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir WaitHandle sinyal alana kadar geçerli iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32)	Geçerli iş parçacığını, milisaniye cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak, geçerli WaitHandle iş parçacığını bir sinyal alana kadar engeller. (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ılıp çıkılmayacağını belirtir. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan)	Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır. (Devralındığı yer: WaitHandle)

Uzantı Metotları

Name	Description
GetAccessControl(Semaphore)	Belirtilen semaphoreiçin güvenlik tanımlayıcılarını döndürür.
GetSafeWaitHandle(WaitHandle)	Yerel işletim sistemi bekleme tutamacını güvenli tutamacını alır.
SetAccessControl(Semaphore, SemaphoreSecurity)	Belirtilen semafor için güvenlik tanımlayıcılarını ayarlar.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Yerel işletim sistemi bekleme tutamacı için güvenli bir tanıtıcı ayarlar.

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

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

Ayrıca bkz.

• Yönetilen İş Parçacıkları
• Semafor