Semaphore Osztály

Definíció

Névtér:

System.Threading

Szerelvény:

System.dll

Korlátozza az erőforrásokhoz vagy erőforráskészletekhez egyidejűleg hozzáférő szálak számát.

public ref class Semaphore sealed : System::Threading::WaitHandle

[System.Runtime.InteropServices.ComVisible(false)]
public sealed class Semaphore : System.Threading.WaitHandle

[<System.Runtime.InteropServices.ComVisible(false)>]
type Semaphore = class
    inherit WaitHandle

Public NotInheritable Class Semaphore
Inherits WaitHandle

Öröklődés

Object

MarshalByRefObject

WaitHandle

Semaphore

Attribútumok

ComVisibleAttribute

Példák

Az alábbi példakód létrehoz egy szemaphore-t, amelynek maximális száma három és a kezdeti szám nulla. A példa öt szálat indít el, amelyek blokkolják a szemapóra várakozást. A fő szál a metódus túlterhelésével Release(Int32) növeli a szemaforok számát a maximális értékre, így három szál léphet be a szemaforba. Minden szál egy Thread.Sleep másodpercig várakozik, szimulálja a munkát, majd meghívja a Release() metódus túlterhelését a szemafor felszabadításához. Minden alkalommal, amikor a szemaphore felszabadul, megjelenik az előző szemaphore-szám. A konzolüzenetek nyomon követik a szemaphore használatát. A szimulált munkaintervallum kissé megnő az egyes szálak esetében, hogy a kimenet könnyebben olvasható legyen.

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

Megjegyzések

Az osztály használatával Semaphore szabályozhatja az erőforrások készletéhez való hozzáférést. A szálak az osztálytól WaitHandle örökölt metódus meghívásával WaitOne lépnek be a szemaforba, és a metódus meghívásával feloldják a szemafortRelease.

A szemaforok száma minden alkalommal csökken, amikor egy szál belép a szemaforba, és növekszik, amikor egy szál felszabadítja a szemaphore-t. Ha a szám nulla, a későbbi kérések blokkolva lesznek, amíg más szálak fel nem oldják a szemaphore-t. Amikor az összes szál kiadta a szemaphore-t, a szám a szemafor létrehozásakor megadott maximális értéken van megadva.

Nincs olyan garantált sorrend, mint a FIFO vagy a LIFO, amelyben a blokkolt szálak belépnek a szemaforba.

Egy szál többször is be tud lépni a szemaforba a metódus ismételt meghívásával WaitOne . E bejegyzések némelyikének vagy mindegyikének kiadásához a szál többször is meghívhatja a paraméter nélküli Release() metódus túlterhelését, vagy meghívhatja azt a Release(Int32) metódust, amely meghatározza a felszabadítandó bejegyzések számát.

Az Semaphore osztály nem kényszeríti ki a szál identitását a bejövő WaitOne vagy Releasea . A programozó felelőssége annak biztosítása, hogy a szálak ne engedjenek túl sokszor a szemapóra. Tegyük fel például, hogy a szemaforok maximális száma kettő, és az A és a B szál egyaránt a szemaforba kerül. Ha a B szál programozási hibája miatt kétszer meghívja a Release-t, mindkét hívás sikeres lesz. A szemafor számlálója megtelt, és amikor az A szál végül meghívja Release, egy SemaphoreFullException kivétel dobódik.

A szemaphorok két típusból állnak: a helyi szemaforok és a nevesített rendszer-szemaphorok. Ha egy Semaphore nevet elfogadó konstruktor használatával hoz létre objektumot, az az adott nevű operációsrendszer-szemaforhoz van társítva. A nevesített rendszerszemaforok az operációs rendszer egészében láthatók, és a folyamatok tevékenységeinek szinkronizálására használhatók. Több Semaphore objektumot is létrehozhat, amelyek ugyanazt a névvel ellátott rendszerszemafort jelölik, és a OpenExisting metódus használatával megnyithat egy meglévő nevesített rendszerszemafort.

Egy helyi szemafor csak a folyamaton belül létezik. A folyamatot bármely olyan szál használhatja, amely hivatkozik a helyi Semaphore objektumra. Minden Semaphore objektum egy külön helyi szemaphore.

Figyelmeztetés

Alapértelmezés szerint a névvel ellátott szemaphore nem korlátozódik az azt létrehozó felhasználóra. Más felhasználók megnyithatják és használhatják a szemaphore-t, beleértve a szemapóra megzavarását a szemafor többszöri beszerzésével, és nem szabadítva fel. Az adott felhasználók hozzáférésének korlátozásához használhat konstruktor túlterhelést, vagy SemaphoreAcl átadhat egy adott felhasználót SemaphoreSecurity a nevesített szemaphore létrehozásakor. Ne használjon elnevezett szemaphorokat hozzáférési korlátozások nélkül azokra a rendszerekre, amelyeken esetleg nem megbízható felhasználók futtatnak kódot.

Konstruktorok

Name	Description
Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)	Inicializálja az Semaphore osztály egy új példányát, megadva a bejegyzések kezdeti számát és az egyidejű bejegyzések maximális számát, opcionálisan megadva a rendszer szemaphore-objektumának nevét, megadva egy változót, amely egy értéket kap, amely jelzi, hogy új rendszerszemafor jött-e létre, és megadja a rendszer szemapóra biztonsági hozzáférés-vezérlését.
Semaphore(Int32, Int32, String, Boolean)	Inicializálja az Semaphore osztály új példányát, megadva a bejegyzések kezdeti számát és az egyidejű bejegyzések maximális számát, opcionálisan megadja a rendszer szemaphore-objektumának nevét, és megad egy változót, amely egy értéket kap, amely jelzi, hogy létrejött-e új rendszerszemafor.
Semaphore(Int32, Int32, String)	Inicializálja az Semaphore osztály új példányát, megadja a bejegyzések kezdeti számát és az egyidejű bejegyzések maximális számát, és opcionálisan megadja a rendszer szemaphore objektumának nevét.
Semaphore(Int32, Int32)	Inicializálja az Semaphore osztály új példányát, megadva a bejegyzések kezdeti számát és az egyidejű bejegyzések maximális számát.

Mezők

Name	Description
WaitTimeout	Azt jelzi, hogy egy WaitAny(WaitHandle[], Int32, Boolean) művelet időtúllépést jelzett a várakozási fogópontok jelzése előtt. Ez a mező állandó. (Öröklődés forrása WaitHandle)

Tulajdonságok

Name	Description
Handle	Elavult. Lekéri vagy beállítja a natív operációsrendszer-leírót. (Öröklődés forrása WaitHandle)
SafeWaitHandle	Lekéri vagy beállítja a natív operációsrendszer-leírót. (Öröklődés forrása WaitHandle)

Metódusok

Name	Description
Close()	Az aktuális WaitHandleerőforrás összes erőforrását felszabadítja. (Öröklődés forrása WaitHandle)
CreateObjRef(Type)	Létrehoz egy objektumot, amely tartalmazza a távoli objektumokkal való kommunikációhoz használt proxy létrehozásához szükséges összes releváns információt. (Öröklődés forrása MarshalByRefObject)
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja WaitHandle . (Öröklődés forrása WaitHandle)
Dispose(Boolean)	Ha egy származtatott osztályban felül van bírálva, kiadja a nem felügyelt erőforrásokat, amelyeket a WaitHandlerendszer használ, és opcionálisan felszabadítja a felügyelt erőforrásokat. (Öröklődés forrása WaitHandle)
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetAccessControl()	Lekéri a hozzáférés-vezérlés biztonságát egy nevesített rendszerszemapóhoz.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetLifetimeService()	Lekéri a példány élettartamszabályzatát vezérlő aktuális élettartam-szolgáltatásobjektumot. (Öröklődés forrása MarshalByRefObject)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
InitializeLifetimeService()	Beolvas egy élettartam-szolgáltatásobjektumot a példány élettartam-szabályzatának szabályozásához. (Öröklődés forrása MarshalByRefObject)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
MemberwiseClone(Boolean)	Az aktuális MarshalByRefObject objektum sekély másolatát hozza létre. (Öröklődés forrása MarshalByRefObject)
OpenExisting(String, SemaphoreRights)	Megnyitja a megadott nevű szemaphore-t, ha már létezik, a kívánt biztonsági hozzáféréssel.
OpenExisting(String)	Megnyitja a megadott névvel ellátott szemaphore-t, ha már létezik.
Release()	Kilép a szemapóból, és visszaadja az előző számot.
Release(Int32)	Egy megadott számú alkalommal kilép a szemapóból, és az előző számot adja vissza.
SetAccessControl(SemaphoreSecurity)	Beállítja a hozzáférés-vezérlés biztonságát egy nevesített rendszerszemapóhoz.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
TryOpenExisting(String, Semaphore)	Megnyitja a megadott névvel ellátott szemafortot, ha már létezik, és egy értéket ad vissza, amely jelzi, hogy a művelet sikeres volt-e.
TryOpenExisting(String, SemaphoreRights, Semaphore)	Megnyitja a megadott nevű szemaphore-t, ha már létezik, a kívánt biztonsági hozzáféréssel, és visszaad egy értéket, amely jelzi, hogy a művelet sikeres volt-e.
WaitOne()	Blokkolja az aktuális szálat, amíg az áram WaitHandle nem kap jelet. (Öröklődés forrása WaitHandle)
WaitOne(Int32, Boolean)	Blokkolja az aktuális szálat, amíg az aktuális WaitHandle nem kap jelet, egy 32 bites aláírt egész számmal adja meg az időintervallumot, és adja meg, hogy a várakozás előtt ki kell-e lépnie a szinkronizálási tartományból. (Öröklődés forrása WaitHandle)
WaitOne(Int32)	Blokkolja az aktuális szálat, amíg az aktuális WaitHandle nem kap jelet, egy 32 bites aláírt egész számmal adja meg az időintervallumot ezredmásodpercben. (Öröklődés forrása WaitHandle)
WaitOne(TimeSpan, Boolean)	Letiltja az aktuális szálat, amíg az aktuális példány nem kap jelet, az időintervallum megadásához és annak megadásához, TimeSpan hogy a várakozás előtt kilépjen-e a szinkronizálási tartományból. (Öröklődés forrása WaitHandle)
WaitOne(TimeSpan)	Letiltja az aktuális szálat, amíg az aktuális példány nem kap jelet az TimeSpan időintervallum megadásához. (Öröklődés forrása WaitHandle)

Bővítő metódusok

Name	Description
GetSafeWaitHandle(WaitHandle)	Lekéri a natív operációs rendszer várakozási fogópontjának biztonságos fogópontját.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Beállít egy biztonságos fogópontot a natív operációs rendszer várakozási fogópontjához.

Szálbiztonság

Ez a típus szálbiztos.

Lásd még

• felügyelt szálkezelés
• Szemafor