Semaphore Klas

Definitie

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

Overname

Object

WaitHandle

Semaphore

Overname

Object

MarshalByRefObject

WaitHandle

Semaphore

Kenmerken

ComVisibleAttribute

Voorbeelden

In het volgende codevoorbeeld wordt een semaphore gemaakt met een maximumaantal van drie en een eerste telling van nul. In het voorbeeld worden vijf threads gestart, die blok wachten op de semaphore. De hoofdthread gebruikt de overbelasting van de Release(Int32) methode om het aantalemaforen tot het maximum te verhogen, zodat drie threads de semaphore kunnen invoeren. Elke thread gebruikt de Thread.Sleep methode om één seconde te wachten, om werk te simuleren en roept vervolgens de overbelasting van de methode aan om de Release() semafoor vrij te geven. Telkens wanneer deemafore wordt vrijgegeven, wordt het vorige aantal semaphore weergegeven. Consoleberichten houden het gebruik van de semafore bij. Het gesimuleerde werkinterval wordt enigszins verhoogd voor elke thread, zodat de uitvoer gemakkelijker te lezen is.

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

Opmerkingen

Gebruik de klasse om de Semaphore toegang tot een groep resources te beheren. Threads voeren deemafore in door de WaitOne methode aan te roepen, die wordt overgenomen van de WaitHandle klasse en de semafor vrij te geven door de methode aan te Release roepen.

Het aantal op een semaphore wordt steeds afgebroken wanneer een draad de semafor binnenkomt en verhoogd wanneer een thread de semaphore vrijgeeft. Wanneer het aantal nul is, worden volgende aanvragen geblokkeerd totdat andere threads de semaphore vrijgeven. Wanneer alle threads deemafore hebben vrijgegeven, is het aantal de maximumwaarde die is opgegeven toen de semaphore werd gemaakt.

Er is geen gegarandeerde volgorde, zoals FIFO of LIFO, waarin geblokkeerde threads de semaphore binnenkomen.

Een thread kan meerdere keren deemafore invoeren door de WaitOne methode herhaaldelijk aan te roepen. Als u sommige of al deze vermeldingen wilt vrijgeven, kan de thread de overbelasting van de parameterloze Release() methode meerdere keren aanroepen, of de methode-overbelasting aanroepen Release(Int32) waarmee het aantal vermeldingen wordt opgegeven dat moet worden vrijgegeven.

De Semaphore klasse dwingt geen thread-identiteit af voor aanroepen naar WaitOne of Release. Het is de verantwoordelijkheid van de programmeur om ervoor te zorgen dat threads niet te vaak de semafore vrijgeven. Stel dat een semaphore een maximumaantal van twee heeft en dat thread A en thread B beide de semaphore binnenkomen. Als een programmeerfout in thread B ervoor zorgt dat Release twee keer wordt aangeroepen, slagen beide aanroepen. Het aantal op de semaphore is vol, en wanneer thread A Release aanroept, uiteindelijk wordt er een SemaphoreFullException gegenereerd.

Semaphores zijn van twee typen: lokale semaphores en benoemde systeemsemaforen. Als u een Semaphore object maakt met behulp van een constructor die een naam accepteert, wordt het gekoppeld aan een besturingssysteemmafore van die naam. Benoemde systeemmaforen zijn zichtbaar in het hele besturingssysteem en kunnen worden gebruikt om de activiteiten van processen te synchroniseren. U kunt meerdere Semaphore objecten maken die dezelfde benoemde systeememafore vertegenwoordigen en u kunt de OpenExisting methode gebruiken om een bestaand benoemd systeememafore te openen.

Er bestaat alleen een lokale semaphore binnen uw proces. Het kan worden gebruikt door elke thread in uw proces die een verwijzing naar het lokale Semaphore object heeft. Elk Semaphore object is een afzonderlijke lokale semaphore.

Veiligheid thread

Dit type is thread veilig.

Zie ook

• Het Beheerd Draadbeheer
• Semafoor