Semaphore Konstruktory

Definicja

Przestrzeń nazw:

System.Threading

Zestawy:

netstandard.dll, System.Threading.dll

Inicjuje nowe wystąpienie klasy Semaphore.

Przeciążenia

Nazwa	Opis
Semaphore(Int32, Int32)	Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę równoczesnych wpisów.
Semaphore(Int32, Int32, String)	Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych oraz opcjonalnie określając nazwę obiektu semafora systemowego.
Semaphore(Int32, Int32, String, Boolean)	Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych, opcjonalnie określając nazwę obiektu semafora systemowego i określając zmienną, która odbiera wartość wskazującą, czy został utworzony nowy semafor systemu.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions)	Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych oraz opcjonalnie określając nazwę obiektu semafora systemowego i opcji ustawiania dostępu do zakresu użytkownika i zakresu sesji.
Semaphore(Int32, Int32, String, NamedWaitHandleOptions, Boolean)	Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych, opcjonalnie określając nazwę obiektu semafora systemowego i opcji ustawiania dostępu do zakresu użytkownika i zakresu sesji oraz określając zmienną, która odbiera wartość wskazującą, czy został utworzony nowy semafor systemu.

Semaphore(Int32, Int32)

Źródło:

Semaphore.cs

Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę równoczesnych wpisów.

public:
 Semaphore(int initialCount, int maximumCount);

public Semaphore(int initialCount, int maximumCount);

new System.Threading.Semaphore : int * int -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer)

Parametry

initialCount

Int32

Początkowa liczba żądań semafora, które można udzielić współbieżnie.

maximumCount

Int32

Maksymalna liczba żądań semafora, które można udzielić jednocześnie.

Wyjątki

ArgumentException

initialCount jest większa niż maximumCount.

ArgumentOutOfRangeException

maximumCount wartość jest mniejsza niż 1.

— lub —

initialCount wartość jest mniejsza niż 0.

Przykłady

Poniższy przykład tworzy semafor z maksymalną liczbą trzech i początkową liczbą zera. W przykładzie uruchamia się pięć wątków, które blokują oczekiwanie na semafor. Główny wątek używa Release(Int32) przeciążenia metody, aby zwiększyć liczbę semaforów do maksymalnej, umożliwiając trzy wątki wejścia semafora. Każdy wątek używa Thread.Sleep metody , aby poczekać na jedną sekundę, zasymulować pracę, a następnie wywołuje Release() przeciążenie metody w celu zwolnienia semafora. Za każdym razem, gdy semafor jest zwalniany, wyświetlana jest poprzednia liczba semaforów. Komunikaty konsoli śledzą użycie semafora. Symulowany interwał pracy jest nieznacznie zwiększany dla każdego wątku, aby ułatwić odczytywanie danych wyjściowych.

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

Uwagi

Ten konstruktor inicjuje nienazwany semafor. Wszystkie wątki używające wystąpienia takiego semafora muszą mieć odwołania do wystąpienia.

Jeśli initialCount wartość jest mniejsza niż maximumCount, efekt jest taki sam, jak w przypadku, gdy bieżący wątek został wywołany WaitOne (maximumCount minus initialCount) razy. Jeśli nie chcesz zarezerwować żadnych wpisów dla wątku, który tworzy semafor, użyj tej samej liczby dla maximumCount i initialCount.

Zobacz też

• Zarządzane wątkowanie
• Semafora

Semaphore(Int32, Int32, String)

Źródło:

Semaphore.cs

Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych oraz opcjonalnie określając nazwę obiektu semafora systemowego.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name);

public Semaphore(int initialCount, int maximumCount, string? name);

new System.Threading.Semaphore : int * int * string -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String)

Parametry

initialCount

Int32

Początkowa liczba żądań semafora, które można udzielić współbieżnie.

maximumCount

Int32

Maksymalna liczba żądań semafora, które można udzielić jednocześnie.

name

String

Nazwa, jeśli obiekt synchronizacji ma być współużytkowany z innymi procesami; null w przeciwnym razie lub pusty ciąg. W nazwie jest rozróżniana wielkość liter. Znak ukośnika odwrotnego (\) jest zarezerwowany i może służyć tylko do określania przestrzeni nazw. Aby uzyskać więcej informacji na temat przestrzeni nazw, zobacz sekcję uwagi. W zależności od systemu operacyjnego mogą istnieć dalsze ograniczenia dotyczące nazwy. Na przykład w systemach operacyjnych opartych na systemie Unix nazwa po wykluczeniu przestrzeni nazw musi być prawidłową nazwą pliku.

Wyjątki

ArgumentException

initialCount jest większa niż maximumCount.

— lub —

tylko .NET Framework: name jest dłuższy niż MAX_PATH (260 znaków).

ArgumentOutOfRangeException

maximumCount wartość jest mniejsza niż 1.

— lub —

initialCount wartość jest mniejsza niż 0.

IOException

name jest nieprawidłowy. Może to być z różnych powodów, w tym niektóre ograniczenia, które mogą zostać umieszczone przez system operacyjny, takie jak nieznany prefiks lub nieprawidłowe znaki. Należy pamiętać, że w nazwach i typowych prefiksach "Global\" i "Local\" uwzględniana jest wielkość liter.

— lub —

Wystąpił inny błąd. Właściwość HResult może zawierać więcej informacji.

DirectoryNotFoundException

Windows tylko: name określono nieznaną przestrzeń nazw. Aby uzyskać więcej informacji, zobacz Nazwy obiektów .

PathTooLongException

Element name jest za długi. Ograniczenia długości mogą zależeć od systemu operacyjnego lub konfiguracji.

UnauthorizedAccessException

Nazwany semafor istnieje i ma zabezpieczenia kontroli dostępu, a użytkownik nie ma FullControl.

WaitHandleCannotBeOpenedException

Nie można utworzyć obiektu synchronizacji z podanym name obiektem. Obiekt synchronizacji innego typu może mieć taką samą nazwę.

Przykłady

W poniższym przykładzie kodu pokazano zachowanie procesu krzyżowego nazwanego semafora. W przykładzie zostanie utworzony nazwany semafor z maksymalną liczbą pięciu i początkową liczbą pięciu. Program wykonuje trzy wywołania WaitOne metody . W związku z tym, jeśli uruchomisz skompilowany przykład z dwóch okien poleceń, druga kopia zablokuje trzecie wywołanie metody .WaitOne Zwolnij co najmniej jeden wpis w pierwszej kopii programu, aby odblokować drugi.

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // Create a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample3". The semaphore has a
        // maximum count of five. The initial count is also five. 
        // There is no point in using a smaller initial count,
        // because the initial count is not used if this program
        // doesn't create the named system semaphore, and with 
        // this method overload there is no way to tell. Thus, this
        // program assumes that it is competing with other
        // programs for the semaphore.
        //
        Semaphore sem = new Semaphore(5, 5, "SemaphoreExample3");

        // Attempt to enter the semaphore three times. If another 
        // copy of this program is already running, only the first
        // two requests can be satisfied. The third blocks. Note 
        // that in a real application, timeouts should be used
        // on the WaitOne calls, to avoid deadlocks.
        //
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore once.");
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore twice.");
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore three times.");

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    }
}

Imports System.Threading

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' Create a Semaphore object that represents the named 
        ' system semaphore "SemaphoreExample3". The semaphore has a
        ' maximum count of five. The initial count is also five. 
        ' There is no point in using a smaller initial count,
        ' because the initial count is not used if this program
        ' doesn't create the named system semaphore, and with 
        ' this method overload there is no way to tell. Thus, this
        ' program assumes that it is competing with other
        ' programs for the semaphore.
        '
        Dim sem As New Semaphore(5, 5, "SemaphoreExample3")

        ' Attempt to enter the semaphore three times. If another 
        ' copy of this program is already running, only the first
        ' two requests can be satisfied. The third blocks. Note 
        ' that in a real application, timeouts should be used
        ' on the WaitOne calls, to avoid deadlocks.
        '
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore once.")
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore twice.")
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore three times.")

        ' The thread executing this program has entered the 
        ' semaphore three times. If a second copy of the program
        ' is run, it will block until this program releases the 
        ' semaphore at least once.
        '
        Console.WriteLine("Enter the number of times to call Release.")
        Dim n As Integer
        If Integer.TryParse(Console.ReadLine(), n) Then
            sem.Release(n)
        End If

        Dim remaining As Integer = 3 - n
        If (remaining) > 0 Then
            Console.WriteLine("Press Enter to release the remaining " _
                & "count ({0}) and exit the program.", remaining)
            Console.ReadLine()
            sem.Release(remaining)
        End If

    End Sub 
End Class

Uwagi

Ten konstruktor inicjuje Semaphore obiekt reprezentujący nazwany semafor systemowy. Można utworzyć wiele Semaphore obiektów reprezentujących ten sam semafor systemowy.

Element name może być poprzedzony prefiksem Global\ lub Local\ , aby określić przestrzeń nazw. Po określeniu Global przestrzeni nazw obiekt synchronizacji może być współużytkowany z dowolnymi procesami w systemie. Po określeniu Local przestrzeni nazw, która jest również wartością domyślną, gdy nie określono żadnej przestrzeni nazw, obiekt synchronizacji może być współużytkowany z procesami w tej samej sesji. W Windows sesja jest sesją logowania, a usługi są zwykle uruchamiane w innej sesji nieinterakcyjnej. W systemach operacyjnych podobnych do unix każda powłoka ma własną sesję. Obiekty synchronizacji lokalnej sesji mogą być odpowiednie do synchronizacji między procesami z relacją nadrzędną/podrzędną, w której wszystkie są uruchamiane w tej samej sesji. Aby uzyskać więcej informacji na temat nazw obiektów synchronizacji w Windows, zobacz Object Names.

name Jeśli element jest podany, a obiekt synchronizacji żądanego typu już istnieje w przestrzeni nazw, używany jest istniejący obiekt synchronizacji. Jeśli obiekt synchronizacji innego typu już istnieje w przestrzeni nazw, WaitHandleCannotBeOpenedException zostanie zgłoszony element . W przeciwnym razie zostanie utworzony nowy obiekt synchronizacji.

Jeśli nazwany semafor systemowy nie istnieje, jest tworzony z początkową liczbą i maksymalną liczbą określoną przez initialCount i maximumCount. Jeśli nazwany semafor systemowy już istnieje initialCount i maximumCount nie jest używany, chociaż nieprawidłowe wartości nadal powodują wyjątki. Jeśli musisz określić, czy został utworzony nazwany semafor systemowy, należy zamiast tego użyć przeciążenia konstruktora Semaphore(Int32, Int32, String, Boolean) .

Ważna

Jeśli używasz tego przeciążenia konstruktora, zalecaną praktyką jest określenie tej samej liczby dla initialCount i maximumCount. Jeśli initialCount wartość jest mniejsza niż maximumCount, a tworzony jest nazwany semafor systemowy, efekt jest taki sam jak wtedy, gdy bieżący wątek miał wywołaną WaitOne wartość (maximumCount minus initialCount) razy. Jednak w przypadku tego przeciążenia konstruktora nie ma możliwości określenia, czy został utworzony nazwany semafor systemu.

Jeśli określisz null ciąg lub ciąg pusty dla name, zostanie utworzony lokalny semafor, tak jak w przypadku wywołania przeciążenia konstruktora Semaphore(Int32, Int32) .

Ponieważ nazwane semafory są widoczne w całym systemie operacyjnym, mogą służyć do koordynowania użycia zasobów przez granice procesu.

Jeśli chcesz dowiedzieć się, czy istnieje nazwany semafor systemowy, użyj OpenExisting metody . Metoda OpenExisting próbuje otworzyć istniejący semafor o nazwie i zgłasza wyjątek, jeśli semafor systemu nie istnieje.

Caution

Domyślnie nazwany semafor nie jest ograniczony do użytkownika, który go utworzył. Inni użytkownicy mogą być w stanie otworzyć i użyć semafora, w tym zakłócać semafor, uzyskując semafor wiele razy i nie zwalniając go. Aby ograniczyć dostęp do określonych użytkowników, można użyć przeciążenia konstruktora lub SemaphoreAcl przekazać SemaphoreSecurity element podczas tworzenia nazwanego semafora. Unikaj używania nazwanych semaforów bez ograniczeń dostępu do systemów, które mogą mieć niezaufanych użytkowników z uruchomionym kodem.

Zobacz też

• Zarządzane wątkowanie
• Semafora

Semaphore(Int32, Int32, String, Boolean)

Źródło:

Semaphore.cs

Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych, opcjonalnie określając nazwę obiektu semafora systemowego i określając zmienną, która odbiera wartość wskazującą, czy został utworzony nowy semafor systemu.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew);

public Semaphore(int initialCount, int maximumCount, string? name, out bool createdNew);

new System.Threading.Semaphore : int * int * string * bool -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String, ByRef createdNew As Boolean)

Parametry

initialCount

Int32

Początkowa liczba żądań semafora, które mogą być spełnione jednocześnie.

maximumCount

Int32

Maksymalna liczba żądań semafora, które mogą być spełnione jednocześnie.

name

String

Nazwa, jeśli obiekt synchronizacji ma być współużytkowany z innymi procesami; null w przeciwnym razie lub pusty ciąg. W nazwie jest rozróżniana wielkość liter. Znak ukośnika odwrotnego (\) jest zarezerwowany i może służyć tylko do określania przestrzeni nazw. Aby uzyskać więcej informacji na temat przestrzeni nazw, zobacz sekcję uwagi. W zależności od systemu operacyjnego mogą istnieć dalsze ograniczenia dotyczące nazwy. Na przykład w systemach operacyjnych opartych na systemie Unix nazwa po wykluczeniu przestrzeni nazw musi być prawidłową nazwą pliku.

createdNew

Boolean

Gdy ta metoda zwraca metodę, zawiera true , czy został utworzony lokalny semafor (czyli jeśli name jest lub null pusty ciąg) lub jeśli został utworzony określony semafor systemowy; false jeśli określony nazwany semafor systemowy już istniał. Ten parametr jest przekazywany niezainicjowany.

Wyjątki

ArgumentException

initialCount jest większa niż maximumCount.

— lub —

tylko .NET Framework: name jest dłuższy niż MAX_PATH (260 znaków).

ArgumentOutOfRangeException

maximumCount wartość jest mniejsza niż 1.

— lub —

initialCount wartość jest mniejsza niż 0.

IOException

name jest nieprawidłowy. Może to być z różnych powodów, w tym niektóre ograniczenia, które mogą zostać umieszczone przez system operacyjny, takie jak nieznany prefiks lub nieprawidłowe znaki. Należy pamiętać, że w nazwach i typowych prefiksach "Global\" i "Local\" uwzględniana jest wielkość liter.

— lub —

Wystąpił inny błąd. Właściwość HResult może zawierać więcej informacji.

DirectoryNotFoundException

Windows tylko: name określono nieznaną przestrzeń nazw. Aby uzyskać więcej informacji, zobacz Nazwy obiektów .

PathTooLongException

Element name jest za długi. Ograniczenia długości mogą zależeć od systemu operacyjnego lub konfiguracji.

UnauthorizedAccessException

Nazwany semafor istnieje i ma zabezpieczenia kontroli dostępu, a użytkownik nie ma FullControl.

WaitHandleCannotBeOpenedException

Nie można utworzyć obiektu synchronizacji z podanym name obiektem. Obiekt synchronizacji innego typu może mieć taką samą nazwę.

Przykłady

W poniższym przykładzie kodu pokazano zachowanie procesu krzyżowego nazwanego semafora. W przykładzie zostanie utworzony nazwany semafor z maksymalną liczbą pięciu i początkową liczbą dwóch. Oznacza to, że rezerwuje trzy wpisy dla wątku, który wywołuje konstruktor. Jeśli createNew to false, program wykonuje trzy wywołania WaitOne metody . W związku z tym, jeśli uruchomisz skompilowany przykład z dwóch okien poleceń, druga kopia zablokuje trzecie wywołanie metody .WaitOne Zwolnij co najmniej jeden wpis w pierwszej kopii programu, aby odblokować drugi.

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // The value of this variable is set by the semaphore
        // constructor. It is true if the named system semaphore was
        // created, and false if the named semaphore already existed.
        //
        bool semaphoreWasCreated;

        // Create a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample". The semaphore has a
        // maximum count of five, and an initial count of two. The
        // Boolean value that indicates creation of the underlying 
        // system object is placed in semaphoreWasCreated.
        //
        Semaphore sem = new Semaphore(2, 5, "SemaphoreExample", 
            out semaphoreWasCreated);

        if (semaphoreWasCreated)
        {
            // If the named system semaphore was created, its count is
            // set to the initial count requested in the constructor.
            // In effect, the current thread has entered the semaphore
            // three times.
            // 
            Console.WriteLine("Entered the semaphore three times.");
        }
        else
        {      
            // If the named system semaphore was not created,  
            // attempt to enter it three times. If another copy of
            // this program is already running, only the first two
            // requests can be satisfied. The third blocks.
            //
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore once.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore twice.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore three times.");
        }

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    } 
}

Imports System.Threading

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' The value of this variable is set by the semaphore
        ' constructor. It is True if the named system semaphore was
        ' created, and False if the named semaphore already existed.
        '
        Dim semaphoreWasCreated As Boolean

        ' Create a Semaphore object that represents the named 
        ' system semaphore "SemaphoreExample". The semaphore has a
        ' maximum count of five, and an initial count of two. The
        ' Boolean value that indicates creation of the underlying 
        ' system object is placed in semaphoreWasCreated.
        '
        Dim sem As New Semaphore(2, 5, "SemaphoreExample", _
            semaphoreWasCreated)

        If semaphoreWasCreated Then
            ' If the named system semaphore was created, its count is
            ' set to the initial count requested in the constructor.
            ' In effect, the current thread has entered the semaphore
            ' three times.
            ' 
            Console.WriteLine("Entered the semaphore three times.")
        Else
            ' If the named system semaphore was not created,  
            ' attempt to enter it three times. If another copy of
            ' this program is already running, only the first two
            ' requests can be satisfied. The third blocks.
            '
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore once.")
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore twice.")
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore three times.")
        End If

        ' The thread executing this program has entered the 
        ' semaphore three times. If a second copy of the program
        ' is run, it will block until this program releases the 
        ' semaphore at least once.
        '
        Console.WriteLine("Enter the number of times to call Release.")
        Dim n As Integer
        If Integer.TryParse(Console.ReadLine(), n) Then
            sem.Release(n)
        End If

        Dim remaining As Integer = 3 - n
        If (remaining) > 0 Then
            Console.WriteLine("Press Enter to release the remaining " _
                & "count ({0}) and exit the program.", remaining)
            Console.ReadLine()
            sem.Release(remaining)
        End If

    End Sub 
End Class

Uwagi

Element name może być poprzedzony prefiksem Global\ lub Local\ , aby określić przestrzeń nazw. Po określeniu Global przestrzeni nazw obiekt synchronizacji może być współużytkowany z dowolnymi procesami w systemie. Po określeniu Local przestrzeni nazw, która jest również wartością domyślną, gdy nie określono żadnej przestrzeni nazw, obiekt synchronizacji może być współużytkowany z procesami w tej samej sesji. W Windows sesja jest sesją logowania, a usługi są zwykle uruchamiane w innej sesji nieinterakcyjnej. W systemach operacyjnych podobnych do unix każda powłoka ma własną sesję. Obiekty synchronizacji lokalnej sesji mogą być odpowiednie do synchronizacji między procesami z relacją nadrzędną/podrzędną, w której wszystkie są uruchamiane w tej samej sesji. Aby uzyskać więcej informacji na temat nazw obiektów synchronizacji w Windows, zobacz Object Names.

name Jeśli element jest podany, a obiekt synchronizacji żądanego typu już istnieje w przestrzeni nazw, używany jest istniejący obiekt synchronizacji. Jeśli obiekt synchronizacji innego typu już istnieje w przestrzeni nazw, WaitHandleCannotBeOpenedException zostanie zgłoszony element . W przeciwnym razie zostanie utworzony nowy obiekt synchronizacji.

Ten konstruktor inicjuje Semaphore obiekt reprezentujący nazwany semafor systemowy. Można utworzyć wiele Semaphore obiektów reprezentujących ten sam semafor systemowy.

Jeśli nazwany semafor systemowy nie istnieje, jest tworzony z początkową liczbą i maksymalną liczbą określoną przez initialCount i maximumCount. Jeśli nazwany semafor systemowy już istnieje initialCount i maximumCount nie jest używany, chociaż nieprawidłowe wartości nadal powodują wyjątki. Użyj createdNew polecenia , aby określić, czy został utworzony semafor systemowy.

Jeśli initialCount wartość jest mniejsza niż maximumCount, i createdNew ma truewartość , efekt jest taki sam, jak w przypadku, gdy bieżący wątek miał wywołaną WaitOne wartość (maximumCount minus initialCount) razy.

Jeśli określisz null ciąg lub ciąg pusty dla name, zostanie utworzony lokalny semafor, tak jak w przypadku wywołania przeciążenia konstruktora Semaphore(Int32, Int32) . W tym przypadku createdNew wartość to zawsze true.

Ponieważ nazwane semafory są widoczne w całym systemie operacyjnym, mogą służyć do koordynowania użycia zasobów przez granice procesu.

Caution

Domyślnie nazwany semafor nie jest ograniczony do użytkownika, który go utworzył. Inni użytkownicy mogą być w stanie otworzyć i użyć semafora, w tym zakłócać semafor, uzyskując semafor wiele razy i nie zwalniając go. Aby ograniczyć dostęp do określonych użytkowników, można użyć przeciążenia konstruktora lub SemaphoreAcl przekazać SemaphoreSecurity element podczas tworzenia nazwanego semafora. Unikaj używania nazwanych semaforów bez ograniczeń dostępu do systemów, które mogą mieć niezaufanych użytkowników z uruchomionym kodem.

Zobacz też

• Zarządzane wątkowanie
• Semafora

Semaphore(Int32, Int32, String, NamedWaitHandleOptions)

Źródło:

Semaphore.cs

Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych oraz opcjonalnie określając nazwę obiektu semafora systemowego i opcji ustawiania dostępu do zakresu użytkownika i zakresu sesji.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name, System::Threading::NamedWaitHandleOptions options);

public Semaphore(int initialCount, int maximumCount, string? name, System.Threading.NamedWaitHandleOptions options);

new System.Threading.Semaphore : int * int * string * System.Threading.NamedWaitHandleOptions -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String, options As NamedWaitHandleOptions)

Parametry

initialCount

Int32

Początkowa liczba żądań semafora, które mogą być spełnione jednocześnie.

maximumCount

Int32

Maksymalna liczba żądań semafora, które mogą być spełnione jednocześnie.

name

String

Nazwa, jeśli obiekt synchronizacji ma być współużytkowany z innymi procesami; null w przeciwnym razie lub pusty ciąg. W nazwie jest rozróżniana wielkość liter.

options

NamedWaitHandleOptions

Opcje zakresu dla nazwanego semafora. Domyślnie dostęp ograniczony do bieżącego użytkownika i bieżącej sesji. Określone opcje mogą mieć wpływ na przestrzeń nazw nazwy i dostęp do bazowego obiektu semafora.

Wyjątki

ArgumentException

initialCount jest większa niż maximumCount.

— lub —

initialCount wartość jest mniejsza niż 0.

IOException

name jest nieprawidłowy. Może to być z różnych powodów, w tym niektóre ograniczenia, które mogą zostać umieszczone przez system operacyjny, takie jak nieznany prefiks lub nieprawidłowe znaki. Należy pamiętać, że w nazwach i typowych prefiksach "Global\" i "Local\" uwzględniana jest wielkość liter.

— lub —

Wystąpił inny błąd. Właściwość HResult może zawierać więcej informacji.

DirectoryNotFoundException

Windows tylko: name określono nieznaną przestrzeń nazw. Aby uzyskać więcej informacji, zobacz Nazwy obiektów .

PathTooLongException

Element name jest za długi. Ograniczenia długości mogą zależeć od systemu operacyjnego lub konfiguracji.

UnauthorizedAccessException

Nazwany semafor istnieje i ma zabezpieczenia kontroli dostępu, a użytkownik nie ma FullControl.

WaitHandleCannotBeOpenedException

Nie można utworzyć obiektu synchronizacji z podanym name obiektem. Obiekt synchronizacji innego typu może mieć taką samą nazwę.

— lub —

Obiekt z określonym name obiektem istnieje, ale określony options nie jest zgodny z opcjami istniejącego obiektu.

Uwagi

Ten konstruktor inicjuje Semaphore obiekt reprezentujący nazwany semafor systemowy. Można utworzyć wiele Semaphore obiektów reprezentujących ten sam semafor systemowy.

name Jeśli obiekt synchronizacji żądanego typu już istnieje w przestrzeni nazw, używany jest istniejący obiekt synchronizacji, chyba że options określa dostęp ograniczony do bieżącego użytkownika, a obiekt synchronizacji nie jest z nim zgodny, w tym przypadku WaitHandleCannotBeOpenedException zgłaszany jest obiekt synchronizacji. Jeśli obiekt synchronizacji innego typu już istnieje w przestrzeni nazw, WaitHandleCannotBeOpenedException zostanie również zgłoszony element . W przeciwnym razie zostanie utworzony nowy obiekt synchronizacji.

Jeśli nazwany semafor systemowy nie istnieje, jest tworzony z początkową liczbą i maksymalną liczbą określoną przez initialCount i maximumCount. Jeśli nazwany semafor systemowy już istnieje initialCount i maximumCount nie jest używany, chociaż nieprawidłowe wartości nadal powodują wyjątki. Jeśli musisz określić, czy został utworzony nazwany semafor systemowy, należy zamiast tego użyć przeciążenia konstruktora Semaphore(Int32, Int32, String, Boolean) .

Ważna

Jeśli używasz tego przeciążenia konstruktora, zalecaną praktyką jest określenie tej samej liczby dla initialCount i maximumCount. Jeśli initialCount wartość jest mniejsza niż maximumCount, a tworzony jest nazwany semafor systemowy, efekt jest taki sam jak wtedy, gdy bieżący wątek miał wywołaną WaitOne wartość (maximumCount minus initialCount) razy. Jednak przy przeciążeniu tego konstruktora nie ma możliwości określenia, czy został utworzony nazwany semafor systemu.

Jeśli określisz null ciąg lub ciąg pusty dla name, zostanie utworzony lokalny semafor, tak jak w przypadku wywołania przeciążenia konstruktora Semaphore(Int32, Int32) .

Ponieważ nazwane semafory są widoczne w całym systemie operacyjnym, mogą służyć do koordynowania użycia zasobów przez granice procesu.

Jeśli chcesz dowiedzieć się, czy istnieje nazwany semafor systemowy, użyj OpenExisting metody . Metoda OpenExisting próbuje otworzyć istniejący semafor o nazwie i zgłasza wyjątek, jeśli semafor systemu nie istnieje.

W Windows options można określić, czy nazwany semafor jest dostępny tylko dla bieżącego użytkownika, czy dla wszystkich użytkowników. Umożliwia również określenie, czy nazwany semafor jest dostępny dla procesów tylko w bieżącej sesji, czy do wszystkich sesji. Aby uzyskać więcej informacji, zobacz NamedWaitHandleOptions.

Caution

W systemach operacyjnych opartych na systemie options Unix parametr nie ma wpływu na nazwane semafory nie są obsługiwane.

Zobacz też

• Zarządzane wątkowanie
• Semafora

Semaphore(Int32, Int32, String, NamedWaitHandleOptions, Boolean)

Źródło:

Semaphore.cs

Inicjuje nowe wystąpienie Semaphore klasy, określając początkową liczbę wpisów i maksymalną liczbę wpisów współbieżnych, opcjonalnie określając nazwę obiektu semafora systemowego i opcji ustawiania dostępu do zakresu użytkownika i zakresu sesji oraz określając zmienną, która odbiera wartość wskazującą, czy został utworzony nowy semafor systemu.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name, System::Threading::NamedWaitHandleOptions options, [Runtime::InteropServices::Out] bool % createdNew);

public Semaphore(int initialCount, int maximumCount, string? name, System.Threading.NamedWaitHandleOptions options, out bool createdNew);

new System.Threading.Semaphore : int * int * string * System.Threading.NamedWaitHandleOptions * bool -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String, options As NamedWaitHandleOptions, ByRef createdNew As Boolean)

Parametry

initialCount

Int32

Początkowa liczba żądań semafora, które mogą być spełnione jednocześnie.

maximumCount

Int32

Maksymalna liczba żądań semafora, które mogą być spełnione jednocześnie.

name

String

Nazwa, jeśli obiekt synchronizacji ma być współużytkowany z innymi procesami; null w przeciwnym razie lub pusty ciąg. W nazwie jest rozróżniana wielkość liter.

options

NamedWaitHandleOptions

Opcje zakresu dla nazwanego semafora. Domyślnie dostęp ograniczony do bieżącego użytkownika i bieżącej sesji. Określone opcje mogą mieć wpływ na przestrzeń nazw nazwy i dostęp do bazowego obiektu semafora.

createdNew

Boolean

Gdy ta metoda zwróci wartość , zawiera true , czy został utworzony lokalny semafor (czyli jeśli name jest lub null pusty ciąg) lub jeśli został utworzony określony semafor systemowy; zawiera false , czy określony nazwany semafor systemowy już istniał. Ten parametr jest przekazywany niezainicjowany.

Wyjątki

ArgumentException

initialCount jest większa niż maximumCount.

— lub —

initialCount wartość jest mniejsza niż 0.

IOException

name jest nieprawidłowy. Może to być z różnych powodów, w tym niektóre ograniczenia, które mogą zostać umieszczone przez system operacyjny, takie jak nieznany prefiks lub nieprawidłowe znaki. Należy pamiętać, że w nazwach i typowych prefiksach "Global\" i "Local\" uwzględniana jest wielkość liter.

— lub —

Wystąpił inny błąd. Właściwość HResult może zawierać więcej informacji.

DirectoryNotFoundException

Windows tylko: name określono nieznaną przestrzeń nazw. Aby uzyskać więcej informacji, zobacz Nazwy obiektów .

PathTooLongException

Element name jest za długi. Ograniczenia długości mogą zależeć od systemu operacyjnego lub konfiguracji.

UnauthorizedAccessException

Nazwany semafor istnieje i ma zabezpieczenia kontroli dostępu, a użytkownik nie ma FullControl.

WaitHandleCannotBeOpenedException

Nie można utworzyć obiektu synchronizacji z podanym name obiektem. Obiekt synchronizacji innego typu może mieć taką samą nazwę.

— lub —

Obiekt z określonym name obiektem istnieje, ale określony options nie jest zgodny z opcjami istniejącego obiektu.

Uwagi

name Jeśli obiekt synchronizacji żądanego typu już istnieje w przestrzeni nazw, używany jest istniejący obiekt synchronizacji, chyba że options określa dostęp ograniczony do bieżącego użytkownika, a obiekt synchronizacji nie jest z nim zgodny, w tym przypadku WaitHandleCannotBeOpenedException zgłaszany jest obiekt synchronizacji. Jeśli obiekt synchronizacji innego typu już istnieje w przestrzeni nazw, WaitHandleCannotBeOpenedException zostanie również zgłoszony element . W przeciwnym razie zostanie utworzony nowy obiekt synchronizacji.

Ten konstruktor inicjuje Semaphore obiekt reprezentujący nazwany semafor systemowy. Można utworzyć wiele Semaphore obiektów reprezentujących ten sam semafor systemowy.

Jeśli nazwany semafor systemowy nie istnieje, jest tworzony z początkową liczbą i maksymalną liczbą określoną przez initialCount i maximumCount. Jeśli nazwany semafor systemowy już istnieje initialCount i maximumCount nie jest używany, chociaż nieprawidłowe wartości nadal powodują wyjątki. Użyj parametru createdNew , aby określić, czy semafor systemowy został utworzony przez tego konstruktora.

Jeśli initialCount wartość jest mniejsza niż maximumCount, i createdNew ma truewartość , efekt jest taki sam, jak w przypadku, gdy bieżący wątek miał wywołaną WaitOne wartość (maximumCount minus initialCount) razy.

Jeśli określisz null ciąg lub ciąg pusty dla name, zostanie utworzony lokalny semafor, tak jak w przypadku wywołania przeciążenia konstruktora Semaphore(Int32, Int32) . W tym przypadku createdNew wartość to zawsze true.

Ponieważ nazwane semafory są widoczne w całym systemie operacyjnym, mogą służyć do koordynowania użycia zasobów przez granice procesu.

W Windows options można określić, czy nazwany semafor jest dostępny tylko dla bieżącego użytkownika, czy dla wszystkich użytkowników. Umożliwia również określenie, czy nazwany semafor jest dostępny dla procesów tylko w bieżącej sesji, czy do wszystkich sesji. Aby uzyskać więcej informacji, zobacz NamedWaitHandleOptions.

Caution

W systemach operacyjnych opartych na systemie options Unix parametr nie ma wpływu na nazwane semafory nie są obsługiwane.

Zobacz też

• Zarządzane wątkowanie
• Semafora