Semaphore Konstruktorer

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

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)

Parametrar

Undantag

Exempel

I följande exempel skapas en semafor med ett maximalt antal på tre och ett initialt antal på noll. Exemplet startar fem trådar, vilket blockerar väntan på semafor. Huvudtråden Release(Int32) använder metodens överbelastning för att öka semaforantalet till sitt maximala, vilket gör att tre trådar kan komma in i semaforen. Varje tråd använder Thread.Sleep metoden för att vänta en sekund, för att simulera arbete och anropar Release() sedan metodens överlagring för att frigöra semaforen. Varje gång semaforen släpps visas det tidigare semaforantalet. Konsolmeddelanden spårar semaforanvändning. Det simulerade arbetsintervallet ökar något för varje tråd för att göra utdata lättare att läsa.

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

Kommentarer

Konstruktorn initierar en icke namngiven semafor. Alla trådar som använder en instans av en sådan semafor måste ha referenser till instansen.

Om initialCount är mindre än maximumCountär effekten samma som om den aktuella tråden hade anropat WaitOne (maximumCount minus initialCount) gånger. Om du inte vill reservera några poster för tråden som skapar semaforen använder du samma tal för maximumCount och initialCount.

Se även

• hanterad trådning
• Semafor

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

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

public Semaphore(int initialCount, int maximumCount, 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)

Parametrar

Undantag

Exempel

I följande kodexempel visas beteendet mellan processer för en namngiven semafor. Exemplet skapar en namngiven semafor med maximalt antal fem och ett inledande antal på fem. Programmet gör tre anrop till WaitOne metoden. Om du kör det kompilerade exemplet från två kommandofönster blockeras den andra kopian av det tredje anropet till WaitOne. Släpp en eller flera poster i den första kopian av programmet för att avblockera den andra.

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

Kommentarer

Konstruktorn initierar ett Semaphore objekt som representerar en namngiven systemsemafor. Du kan skapa flera Semaphore objekt som representerar samma namngivna systemsemafor.

name Kan vara prefix med Global\ eller Local\ för att ange ett namnområde. Global När namnområdet har angetts kan synkroniseringsobjektet delas med alla processer i systemet. Local När namnområdet har angetts, vilket också är standard när inget namnområde anges, kan synkroniseringsobjektet delas med processer i samma session. På Windows är en session en inloggningssession och tjänster körs vanligtvis i en annan icke-interaktiv session. På Unix-liknande operativsystem har varje gränssnitt en egen session. Sessionslokala synkroniseringsobjekt kan vara lämpliga för synkronisering mellan processer med en överordnad/underordnad relation där alla körs i samma session. Mer information om synkroniseringsobjektnamn på Windows finns i Object Names.

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om den namngivna systemsemaforen inte finns skapas den med det initiala antalet och det maximala antalet som anges av initialCount och maximumCount. Om den namngivna systemsemaforen redan finns initialCount och maximumCount inte används, men ogiltiga värden fortfarande orsakar undantag. Om du behöver avgöra om en namngiven Semaphore(Int32, Int32, String, Boolean) systemsemafor har skapats eller inte använder du konstruktorns överlagring i stället.

Om du anger null eller en tom sträng för nameskapas en lokal semafor, som om du hade kallat Semaphore(Int32, Int32) konstruktorns överlagring.

Eftersom namngivna semaphores visas i hela operativsystemet kan de användas för att samordna resursanvändning över processgränser.

Om du vill ta reda på om det finns en namngiven OpenExisting systemsemafor använder du metoden . Metoden OpenExisting försöker öppna en befintlig med namnet semafor och utlöser ett undantag om systemets semafor inte finns.

Se även

• hanterad trådning
• Semafor

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

Källa:

Semaphore.cs

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);

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)

Parametrar

Undantag

Exempel

I följande kodexempel visas beteendet mellan processer för en namngiven semafor. Exemplet skapar en namngiven semafor med maximalt antal fem och ett inledande antal på två. Den reserverar alltså tre poster för tråden som anropar konstruktorn. Om createNew är falsegör programmet tre anrop till WaitOne metoden. Om du kör det kompilerade exemplet från två kommandofönster blockeras den andra kopian av det tredje anropet till WaitOne. Släpp en eller flera poster i den första kopian av programmet för att avblockera den andra.

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

Kommentarer

name Kan vara prefix med Global\ eller Local\ för att ange ett namnområde. Global När namnområdet har angetts kan synkroniseringsobjektet delas med alla processer i systemet. Local När namnområdet har angetts, vilket också är standard när inget namnområde anges, kan synkroniseringsobjektet delas med processer i samma session. På Windows är en session en inloggningssession och tjänster körs vanligtvis i en annan icke-interaktiv session. På Unix-liknande operativsystem har varje gränssnitt en egen session. Sessionslokala synkroniseringsobjekt kan vara lämpliga för synkronisering mellan processer med en överordnad/underordnad relation där alla körs i samma session. Mer information om synkroniseringsobjektnamn på Windows finns i Object Names.

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Konstruktorn initierar ett Semaphore objekt som representerar en namngiven systemsemafor. Du kan skapa flera Semaphore objekt som representerar samma namngivna systemsemafor.

Om den namngivna systemsemaforen inte finns skapas den med det initiala antalet och det maximala antalet som anges av initialCount och maximumCount. Om den namngivna systemsemaforen redan finns initialCount och maximumCount inte används, men ogiltiga värden fortfarande orsakar undantag. Använd createdNew för att avgöra om systemets semafor har skapats.

Om initialCount är mindre än maximumCount, och createdNew är true, är effekten samma som om den aktuella tråden hade anropat WaitOne (maximumCount minus initialCount) gånger.

Om du anger null eller en tom sträng för nameskapas en lokal semafor, som om du hade kallat Semaphore(Int32, Int32) konstruktorns överlagring. I det här fallet createdNew är alltid true.

Eftersom namngivna semaphores visas i hela operativsystemet kan de användas för att samordna resursanvändning över processgränser.

Se även

• hanterad trådning
• Semafor

Källa:

Semaphore.cs

Källa:

Semaphore.cs

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)

Parametrar

Undantag

Kommentarer

Konstruktorn initierar ett Semaphore objekt som representerar en namngiven systemsemafor. Du kan skapa flera Semaphore objekt som representerar samma namngivna systemsemafor.

Om en name tillhandahålls och ett synkroniseringsobjekt av den begärda typen redan finns i namnområdet används det befintliga synkroniseringsobjektet om inte options anger åtkomst som är begränsad till den aktuella användaren och synkroniseringsobjektet inte är kompatibelt med det, i vilket fall ett WaitHandleCannotBeOpenedException genereras. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras även ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om den namngivna systemsemaforen inte finns skapas den med det initiala antalet och det maximala antalet som anges av initialCount och maximumCount. Om den namngivna systemsemaforen redan finns initialCount och maximumCount inte används, men ogiltiga värden fortfarande orsakar undantag. Om du behöver avgöra om en namngiven Semaphore(Int32, Int32, String, Boolean) systemsemafor har skapats eller inte använder du konstruktorns överlagring i stället.

Om du anger null eller en tom sträng för nameskapas en lokal semafor, som om du hade kallat Semaphore(Int32, Int32) konstruktorns överlagring.

Eftersom namngivna semaphores visas i hela operativsystemet kan de användas för att samordna resursanvändning över processgränser.

Om du vill ta reda på om det finns en namngiven OpenExisting systemsemafor använder du metoden . Metoden OpenExisting försöker öppna en befintlig med namnet semafor och utlöser ett undantag om systemets semafor inte finns.

På Windows kan options anges för att ange om den namngivna semaforen endast är tillgänglig för den aktuella användaren eller för alla användare. Du kan också ange om den namngivna semaforen endast är tillgänglig för processer i den aktuella sessionen eller för alla sessioner. Mer information finns i NamedWaitHandleOptions.

Se även

• hanterad trådning
• Semafor

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

public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew, System.Security.AccessControl.SemaphoreSecurity semaphoreSecurity);

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

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

Parametrar

Undantag

Exempel

I följande kodexempel visas beteendet mellan processer för en namngiven semafor med åtkomstkontrollsäkerhet. I exemplet används OpenExisting(String) metodens överlagring för att testa förekomsten av en namngiven semafor. Om semaforen inte finns skapas den med maximalt antal två och med åtkomstkontrollsäkerhet som nekar den aktuella användaren rätten att använda semaforen men ger rätt att läsa och ändra behörigheter för semaforen. Om du kör det kompilerade exemplet från två kommandofönster utlöser den andra kopian ett undantag om åtkomstöverträdelse i anropet OpenExisting(String) till metoden. Undantaget fångas och i exemplet används metodöverbelastningen OpenExisting(String, SemaphoreRights) för att öppna semaforen med de rättigheter som krävs för att läsa och ändra behörigheterna.

När behörigheterna har ändrats öppnas semaforen med de rättigheter som krävs för att ange och släppa. Om du kör det kompilerade exemplet från ett tredje kommandofönster körs det med de nya behörigheterna.

using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string semaphoreName = "SemaphoreExample5";

        Semaphore sem = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // Attempt to open the named semaphore.
        try
        {
            // Open the semaphore with (SemaphoreRights.Synchronize
            // | SemaphoreRights.Modify), to enter and release the
            // named semaphore.
            //
            sem = Semaphore.OpenExisting(semaphoreName);
        }
        catch(WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Semaphore does not exist.");
            doesNotExist = true;
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The semaphore does not exist.
        // (2) The semaphore exists, but the current user doesn't 
        // have access. (3) The semaphore exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The semaphore does not exist, so create it.
            //
            // 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 an access control list (ACL) that denies the
            // current user the right to enter or release the 
            // semaphore, but allows the right to read and change
            // security information for the semaphore.
            //
            string user = Environment.UserDomainName + "\\" 
                + Environment.UserName;
            SemaphoreSecurity semSec = new SemaphoreSecurity();

            SemaphoreAccessRule rule = new SemaphoreAccessRule(
                user, 
                SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                AccessControlType.Deny);
            semSec.AddAccessRule(rule);

            rule = new SemaphoreAccessRule(
                user, 
                SemaphoreRights.ReadPermissions | SemaphoreRights.ChangePermissions,
                AccessControlType.Allow);
            semSec.AddAccessRule(rule);

            // Create a Semaphore object that represents the system
            // semaphore named by the constant 'semaphoreName', with
            // maximum count three, initial count three, and the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object is
            // placed in semaphoreWasCreated.
            //
            sem = new Semaphore(3, 3, semaphoreName, 
                out semaphoreWasCreated, semSec);

            // If the named system semaphore was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program enters the semaphore. Otherwise, exit the
            // program.
            // 
            if (semaphoreWasCreated)
            {
                Console.WriteLine("Created the semaphore.");
            }
            else
            {
                Console.WriteLine("Unable to create the semaphore.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the semaphore to read and change the access
            // control security. The access control security defined
            // above allows the current user to do this.
            //
            try
            {
                sem = Semaphore.OpenExisting(
                    semaphoreName, 
                    SemaphoreRights.ReadPermissions 
                        | SemaphoreRights.ChangePermissions);

                // Get the current ACL. This requires 
                // SemaphoreRights.ReadPermissions.
                SemaphoreSecurity semSec = sem.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\" 
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the semaphore must
                // be removed.
                SemaphoreAccessRule rule = new SemaphoreAccessRule(
                    user, 
                    SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                    AccessControlType.Deny);
                semSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new SemaphoreAccessRule(user, 
                     SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                     AccessControlType.Allow);
                semSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // SemaphoreRights.ChangePermissions.
                sem.SetAccessControl(semSec);

                Console.WriteLine("Updated semaphore security.");

                // Open the semaphore with (SemaphoreRights.Synchronize 
                // | SemaphoreRights.Modify), the rights required to
                // enter and release the semaphore.
                //
                sem = Semaphore.OpenExisting(semaphoreName);
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}", ex.Message);
                return;
            }
        }

        // Enter the semaphore, and hold it until the program
        // exits.
        //
        try
        {
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore.");
            Console.WriteLine("Press the Enter key to exit.");
            Console.ReadLine();
            sem.Release();
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
        }
    }
}

Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const semaphoreName As String = "SemaphoreExample5"

        Dim sem As Semaphore = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' Attempt to open the named semaphore.
        Try
            ' Open the semaphore with (SemaphoreRights.Synchronize
            ' Or SemaphoreRights.Modify), to enter and release the
            ' named semaphore.
            '
            sem = Semaphore.OpenExisting(semaphoreName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Semaphore does not exist.")
            doesNotExist = True
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", ex.Message)
            unauthorized = True
        End Try

        ' There are three cases: (1) The semaphore does not exist.
        ' (2) The semaphore exists, but the current user doesn't 
        ' have access. (3) The semaphore exists and the user has
        ' access.
        '
        If doesNotExist Then
            ' The semaphore does not exist, so create it.
            '
            ' 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 an access control list (ACL) that denies the
            ' current user the right to enter or release the 
            ' semaphore, but allows the right to read and change
            ' security information for the semaphore.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim semSec As New SemaphoreSecurity()

            Dim rule As New SemaphoreAccessRule(user, _
                SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                AccessControlType.Deny)
            semSec.AddAccessRule(rule)

            rule = New SemaphoreAccessRule(user, _
                SemaphoreRights.ReadPermissions Or _
                SemaphoreRights.ChangePermissions, _
                AccessControlType.Allow)
            semSec.AddAccessRule(rule)

            ' Create a Semaphore object that represents the system
            ' semaphore named by the constant 'semaphoreName', with
            ' maximum count three, initial count three, and the
            ' specified security access. The Boolean value that 
            ' indicates creation of the underlying system object is
            ' placed in semaphoreWasCreated.
            '
            sem = New Semaphore(3, 3, semaphoreName, _
                semaphoreWasCreated, semSec)

            ' If the named system semaphore was created, it can be
            ' used by the current instance of this program, even 
            ' though the current user is denied access. The current
            ' program enters the semaphore. Otherwise, exit the
            ' program.
            ' 
            If semaphoreWasCreated Then
                Console.WriteLine("Created the semaphore.")
            Else
                Console.WriteLine("Unable to create the semaphore.")
                Return
            End If

        ElseIf unauthorized Then

            ' Open the semaphore to read and change the access
            ' control security. The access control security defined
            ' above allows the current user to do this.
            '
            Try
                sem = Semaphore.OpenExisting(semaphoreName, _
                    SemaphoreRights.ReadPermissions Or _
                    SemaphoreRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' SemaphoreRights.ReadPermissions.
                Dim semSec As SemaphoreSecurity = sem.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the semaphore must
                ' be removed.
                Dim rule As New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Deny)
                semSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Allow)
                semSec.AddAccessRule(rule)

                ' Update the ACL. This requires
                ' SemaphoreRights.ChangePermissions.
                sem.SetAccessControl(semSec)

                Console.WriteLine("Updated semaphore security.")

                ' Open the semaphore with (SemaphoreRights.Synchronize 
                ' Or SemaphoreRights.Modify), the rights required to
                ' enter and release the semaphore.
                '
                sem = Semaphore.OpenExisting(semaphoreName)

            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unable to change permissions: {0}", _
                    ex.Message)
                Return
            End Try

        End If

        ' Enter the semaphore, and hold it until the program
        ' exits.
        '
        Try
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore.")
            Console.WriteLine("Press the Enter key to exit.")
            Console.ReadLine()
            sem.Release()
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", _
                ex.Message)
        End Try
    End Sub 
End Class

Kommentarer

Använd den här konstruktorn för att tillämpa åtkomstkontrollsäkerhet på en namngiven systemsemafor när den skapas, vilket förhindrar att annan kod tar kontroll över semaforen.

name Kan vara prefix med Global\ eller Local\ för att ange ett namnområde. Global När namnområdet har angetts kan synkroniseringsobjektet delas med alla processer i systemet. Local När namnområdet har angetts, vilket också är standard när inget namnområde anges, kan synkroniseringsobjektet delas med processer i samma session. På Windows är en session en inloggningssession och tjänster körs vanligtvis i en annan icke-interaktiv session. På Unix-liknande operativsystem har varje gränssnitt en egen session. Sessionslokala synkroniseringsobjekt kan vara lämpliga för synkronisering mellan processer med en överordnad/underordnad relation där alla körs i samma session. Mer information om synkroniseringsobjektnamn på Windows finns i Object Names.

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Konstruktorn initierar ett Semaphore objekt som representerar en namngiven systemsemafor. Du kan skapa flera Semaphore objekt som representerar samma namngivna systemsemafor.

Om den namngivna systemsemaforen inte finns skapas den med den angivna åtkomstkontrollsäkerheten. Om den namngivna semaforen finns ignoreras den angivna åtkomstkontrollsäkerheten.

Om den namngivna systemsemaforen inte finns skapas den med det initiala antalet och det maximala antalet som anges av initialCount och maximumCount. Om den namngivna systemsemaforen redan finns initialCount och maximumCount inte används, men ogiltiga värden fortfarande orsakar undantag. Använd parametern createdNew för att avgöra om systemsemaforen skapades av konstruktorn.

Om initialCount är mindre än maximumCount, och createdNew är true, är effekten samma som om den aktuella tråden hade anropat WaitOne (maximumCount minus initialCount) gånger.

Om du anger null eller en tom sträng för nameskapas en lokal semafor, som om du hade kallat Semaphore(Int32, Int32) konstruktorns överlagring. I det här fallet createdNew är alltid true.

Eftersom namngivna semaphores visas i hela operativsystemet kan de användas för att samordna resursanvändning över processgränser.

Se även

• hanterad trådning
• Semafor

Källa:

Semaphore.cs

Källa:

Semaphore.cs

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)

Parametrar

Undantag

Kommentarer

Om en name tillhandahålls och ett synkroniseringsobjekt av den begärda typen redan finns i namnområdet används det befintliga synkroniseringsobjektet om inte options anger åtkomst som är begränsad till den aktuella användaren och synkroniseringsobjektet inte är kompatibelt med det, i vilket fall ett WaitHandleCannotBeOpenedException genereras. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras även ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Konstruktorn initierar ett Semaphore objekt som representerar en namngiven systemsemafor. Du kan skapa flera Semaphore objekt som representerar samma namngivna systemsemafor.

Om den namngivna systemsemaforen inte finns skapas den med det initiala antalet och det maximala antalet som anges av initialCount och maximumCount. Om den namngivna systemsemaforen redan finns initialCount och maximumCount inte används, men ogiltiga värden fortfarande orsakar undantag. Använd parametern createdNew för att avgöra om systemsemaforen skapades av konstruktorn.

Om initialCount är mindre än maximumCount, och createdNew är true, är effekten samma som om den aktuella tråden hade anropat WaitOne (maximumCount minus initialCount) gånger.

Om du anger null eller en tom sträng för nameskapas en lokal semafor, som om du hade kallat Semaphore(Int32, Int32) konstruktorns överlagring. I det här fallet createdNew är alltid true.

Eftersom namngivna semaphores visas i hela operativsystemet kan de användas för att samordna resursanvändning över processgränser.

På Windows kan options anges för att ange om den namngivna semaforen endast är tillgänglig för den aktuella användaren eller för alla användare. Du kan också ange om den namngivna semaforen endast är tillgänglig för processer i den aktuella sessionen eller för alla sessioner. Mer information finns i NamedWaitHandleOptions.

Se även

• hanterad trådning
• Semafor