Semaphore.Release 메서드

정의

네임스페이스:: System.Threading

어셈블리:: System.dll, System.Threading.dll

어셈블리:: netstandard.dll, System.Threading.dll

어셈블리:: System.Threading.dll

어셈블리:: System.dll

어셈블리:: netstandard.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

세마포를 종료합니다.

오버로드

Name	Description
Release()	세마포를 종료하고 이전 수를 반환합니다.
Release(Int32)	지정된 횟수만큼 세마포를 종료하고 이전 개수를 반환합니다.

Release()

Source:: Semaphore.cs

Source:: Semaphore.cs

Source:: Semaphore.cs

Source:: Semaphore.cs

Source:: Semaphore.cs

세마포를 종료하고 이전 수를 반환합니다.

public:
 int Release();

public int Release();

member this.Release : unit -> int

Public Function Release () As Integer

반품

Int32

메서드가 호출되기 전의 세마포 수 Release 입니다.

예외

SemaphoreFullException

세마포 수는 이미 최대값입니다.

IOException

명명된 세마포로 Win32 오류가 발생했습니다.

UnauthorizedAccessException

현재 세마포는 명명된 시스템 세마포를 나타내지만 사용자에게는 Modify없습니다.

-또는-

현재 세마포는 명명된 시스템 세마포를 나타내지만 Modify.

예제

다음 코드 예제에서는 최대 개수 3개와 초기 개수가 0인 세마포를 만듭니다. 이 예제에서는 세마포 대기를 차단하는 5개의 스레드를 시작합니다. 주 스레드는 메서드 오버로드를 사용하여 Release(Int32) 세마포 수를 최대값으로 늘려 세마포에 세마포를 입력할 수 있도록 합니다. 각 스레드는 메서드를 Thread.Sleep 사용하여 1초 동안 기다렸다가 작업을 시뮬레이션한 다음 메서드 오버로드를 호출 Release() 하여 세마포를 해제합니다.

세마포가 해제될 때마다 이전 세마포 수가 표시됩니다. 콘솔 메시지는 세마포 사용을 추적합니다. 출력을 더 쉽게 읽을 수 있도록 각 스레드에 대해 시뮬레이션된 작업 간격이 약간 증가합니다.

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

설명

스레드는 일반적으로 메서드를 WaitOne 사용하여 세마포를 입력하며 일반적으로 이 메서드 오버로드를 사용하여 종료합니다.

메서드에서 SemaphoreFullException throw Release 되는 경우 반드시 호출 스레드에 문제가 있는 것은 아닙니다. 다른 스레드의 프로그래밍 오류로 인해 스레드가 입력한 것보다 세마포를 더 많이 종료했을 수 있습니다.

현재 Semaphore 개체가 명명된 시스템 세마포를 나타내는 경우 사용자에게 권한이 있어야 SemaphoreRights.Modify 하며 세마포가 권한으로 SemaphoreRights.Modify 열렸어야 합니다.

추가 정보

관리되는 스레딩
세마포

적용 대상

Release(Int32)

Source:: Semaphore.cs

Source:: Semaphore.cs

Source:: Semaphore.cs

Source:: Semaphore.cs

Source:: Semaphore.cs

지정된 횟수만큼 세마포를 종료하고 이전 개수를 반환합니다.

public:
 int Release(int releaseCount);

public int Release(int releaseCount);

member this.Release : int -> int

Public Function Release (releaseCount As Integer) As Integer

매개 변수

releaseCount: Int32

세마포를 종료할 횟수입니다.

반품

Int32

메서드가 호출되기 전의 세마포 수 Release 입니다.

예외

ArgumentOutOfRangeException

releaseCount 가 1보다 작습니다.

SemaphoreFullException

세마포 수는 이미 최대값입니다.

IOException

명명된 세마포로 Win32 오류가 발생했습니다.

UnauthorizedAccessException

현재 세마포는 명명된 시스템 세마포를 나타내지만 사용자에게 권한이 Modify 없습니다.

-또는-

현재 세마포는 명명된 시스템 세마포를 나타내지만 권한으로 Modify 열리지 않았습니다.

예제

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

설명

스레드가 세마포를 여러 번 입력한 경우 이 메서드 오버로드를 사용하면 한 번의 호출로 전체 세마포 수를 복원할 수 있습니다.

추가 정보

관리되는 스레딩
세마포

적용 대상

피드백

이 페이지가 도움이 되었나요?