Mutex Mutex Mutex Mutex Class

정의

프로세스 간 동기화에 사용할 수도 있는 동기화 기본 형식입니다.A synchronization primitive that can also be used for interprocess synchronization.

public ref class Mutex sealed : System::Threading::WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle
type Mutex = class
    inherit WaitHandle
Public NotInheritable Class Mutex
Inherits WaitHandle
상속
특성

예제

이 예에서는 로컬 Mutex 개체는 보호 된 리소스에 대 한 액세스를 동기화 하는 데 사용 됩니다.This example shows how a local Mutex object is used to synchronize access to a protected resource. 각 호출 스레드가 뮤텍스의 소유권을 가져올 때까지 차단 하기 때문에 호출 해야 합니다는 ReleaseMutex 스레드는 소유권을 해제 하는 방법입니다.Because each calling thread is blocked until it acquires ownership of the mutex, it must call the ReleaseMutex method to release ownership of the thread.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex
Imports System.Threading

Module Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3
   
   Public Sub Main()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

        ' The main thread exits, but the application continues to
        ' run until all foreground threads have exited.
    End Sub

    Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        mut.WaitOne()

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name)

        ' Place code to access non-reentrant resources here.

        ' Simulate some work.
        Thread.Sleep(500)

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name)

        ' Release the Mutex.
        mut.ReleaseMutex()
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name)
   End Sub
End Module
' The example displays output like the following:
'       Thread1 is requesting the mutex
'       Thread2 is requesting the mutex
'       Thread1 has entered the protected area
'       Thread3 is requesting the mutex
'       Thread1 is leaving the protected area
'       Thread1 has released the mutex
'       Thread3 has entered the protected area
'       Thread3 is leaving the protected area
'       Thread3 has released the mutex
'       Thread2 has entered the protected area
'       Thread2 is leaving the protected area
'       Thread2 has released the mutex

다음 예제에서는 각 스레드 호출을 WaitOne(Int32) 뮤텍스를 획득 하는 방법입니다.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. 메서드가 반환 하는 경우 시간 제한 간격이 경과 하면 false, 스레드가 뮤텍스를 획득 아니고 뮤텍스를 보호 하는 리소스에 대 한 액세스를 향상 하 고 있습니다.If the time-out interval elapses, the method returns false, and the thread neither acquires the mutex nor gains access to the resource the mutex protects. ReleaseMutex 뮤텍스를 획득 하는 스레드에서 메서드가 호출 됩니다.The ReleaseMutex method is called only by the thread that acquires the mutex.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        Example ex = new Example();
        ex.StartThreads();
    }

     private void StartThreads()
     {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread returns to Main and exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter, and do not enter if the request times out.
        Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
        if (mut.WaitOne(1000)) {
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name);
   
           // Place code to access non-reentrant resources here.
   
           // Simulate some work.
           Thread.Sleep(5000);
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name);
   
           // Release the Mutex.
              mut.ReleaseMutex();
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name);
        }
        else {
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name);
        }
    }

    ~Example()
    {
       mut.Dispose();
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread2 is requesting the mutex
//       Thread3 is requesting the mutex
//       Thread2 will not acquire the mutex
//       Thread3 will not acquire the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
Imports System.Threading

Class Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3

   Public Shared Sub Main()
      Dim ex As New Example()
      ex.StartThreads()
   End Sub
   
   Private Sub StartThreads()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

        ' The main thread returns to Main and exits, but the application continues to
        ' run until all foreground threads have exited.
   End Sub

   Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
   End Sub

   ' This method represents a resource that must be synchronized
   ' so that only one thread at a time can enter.
   Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        If mut.WaitOne(1000) Then
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name)
   
           ' Place code to access non-reentrant resources here.
   
           ' Simulate some work.
           Thread.Sleep(5000)
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name)
   
           ' Release the Mutex.
           mut.ReleaseMutex()
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name)
        Else
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name)
        End If
   End Sub
   
   Protected Overrides Sub Finalize()
      mut.Dispose()
   End Sub
End Class
' The example displays output like the following:
'       Thread1 is requesting the mutex
'       Thread1 has entered the protected area
'       Thread2 is requesting the mutex
'       Thread3 is requesting the mutex
'       Thread2 will not acquire the mutex
'       Thread3 will not acquire the mutex
'       Thread1 is leaving the protected area
'       Thread1 has released the mutex

설명

두 개 이상의 스레드를 동시에 공유 리소스에 액세스 해야 하는 경우 시스템 리소스를 한 번에 하나의 스레드만 사용 되도록 동기화 메커니즘이 필요 합니다.When two or more threads need to access a shared resource at the same time, the system needs a synchronization mechanism to ensure that only one thread at a time uses the resource. Mutex 하나의 스레드만 공유 리소스에 대 한 단독 액세스를 부여 하는 기본 동기화 합니다.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. 스레드가 뮤텍스를 획득 하 고 두 번째 스레드는 뮤텍스를 획득 하는 첫 번째 스레드가 뮤텍스를 해제할 때까지 일시 중단 됩니다.If a thread acquires a mutex, the second thread that wants to acquire that mutex is suspended until the first thread releases the mutex.

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다.This type implements the IDisposable interface. 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로의 삭제 해야 있습니다.When you have finished using the type, you should dispose of it either directly or indirectly. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try / catch 블록입니다.To dispose of the type directly, call its Dispose method in a try/catch block. 삭제 하지 직접, 언어 구문 같은 사용 using (C#에서) 또는 Using (Visual Basic에서는).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 자세한 내용은 "를 사용 하는 개체는 구현 IDisposable" 섹션을 참조 하세요.를 IDisposable 인터페이스 항목입니다.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

사용할 수는 WaitHandle.WaitOne 뮤텍스의 소유권을 요청 하는 메서드.You can use the WaitHandle.WaitOne method to request ownership of a mutex. 해당 호출 스레드는 차단 중 하나가 발생할 때까지:The calling thread blocks until one of the following occurs:

  • 뮤텍스는 신호를 소유 하지 않은 것을 나타냅니다.The mutex is signaled to indicate that it is not owned. 이 경우는 WaitOne 메서드가 반환 되는 true, 호출 스레드가 뮤텍스의 소유권을 가정 하 고 뮤텍스 하 여 보호 되는 리소스에 액세스 하 고 있습니다.When this happens, the WaitOne method returns true, and the calling thread assumes ownership of the mutex and accesses the resource protected by the mutex. 스레드 호출 해야 리소스에 액세스할 완료 될 때를 ReleaseMutex 뮤텍스의 소유권을 해제 하는 방법입니다.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. 예제 섹션의 첫 번째 예제에서는이 패턴을 보여 줍니다.The first example in the Examples section illustrates this pattern.

  • 에 대 한 호출에 지정 된 시간 제한 간격을 WaitOne 있는 메서드를 millisecondsTimeout 또는 timeout 매개 합니다.The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. 이 경우는 WaitOne 메서드가 반환 되는 false, 호출 스레드가 뮤텍스의 소유권을 가져오려고 시도 하지 추가 하 고 있습니다.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. 이 경우 호출 스레드가 뮤텍스로 보호 되는 리소스에 대 한 액세스가 거부 되었습니다 있도록 코드를 구성 해야 합니다.In this case, you should structure your code so that access to the resource that is protected by the mutex is denied to the calling thread. 호출 하지 않아야 되지 스레드가 뮤텍스의 소유권을 획득 하기 때문에 ReleaseMutex 메서드.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. 예제 섹션의 두 번째 예제에서는이 패턴을 보여 줍니다.The second example in the Examples section illustrates this pattern.

Mutex 뮤텍스를 획득 하는 스레드에 의해서만 해제 될 수 있으므로 클래스는 스레드 id를 적용 합니다.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. 반면,는 Semaphore 클래스는 스레드 id를 적용 하지 않습니다.By contrast, the Semaphore class does not enforce thread identity. 뮤텍스는 애플리케이션 도메인 경계를 넘어 전달할 수도 있습니다.A mutex can also be passed across application domain boundaries.

뮤텍스를 소유 하는 스레드를 반복된 호출에서 동일한 뮤텍스를 요청할 수 WaitOne 실행을 차단 하지 않고 있습니다.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. 그러나 스레드가 호출 해야 합니다는 ReleaseMutex 메서드 뮤텍스의 소유권을 해제 하려면 동일한 횟수입니다.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

때문에 Mutex 클래스에서 상속 WaitHandle, 정적 호출할 수도 있습니다 WaitHandle.WaitAllWaitHandle.WaitAny 보호 된 리소스에 대 한 액세스를 동기화 하는 방법.Because the Mutex class inherits from WaitHandle, you can also call the static WaitHandle.WaitAll and WaitHandle.WaitAny methods to synchronize access to a protected resource.

스레드가 뮤텍스를 소유 하는 동안 종료 하는 경우 뮤텍스는 중단 될 있다고 합니다.If a thread terminates while owning a mutex, the mutex is said to be abandoned. 뮤텍스의 상태 신호 설정 되 고 대기 스레드는 소유권을 가져옵니다.The state of the mutex is set to signaled, and the next waiting thread gets ownership. .NET Framework 버전 2.0부터는 AbandonedMutexException 중단된 된 뮤텍스를 획득 하는 다음 스레드에서 throw 됩니다.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. .NET Framework 버전 2.0 전에 예외가 throw 되었습니다.Before version 2.0 of the .NET Framework, no exception was thrown.

주의

중단 된 뮤텍스는 종종 코드에서 심각한 오류를 나타냅니다.An abandoned mutex often indicates a serious error in the code. 스레드가 뮤텍스를 해제 하지 않고 종료 되 면 뮤텍스의 보호를 받는 데이터 구조 상태가 일관 되지 않을 수 있습니다.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. 뮤텍스의 소유권을 요청 하는 다음 스레드에서이 예외를 처리 하 고 데이터 구조의 무결성을 확인할 수 있으면 계속할 수 있습니다.The next thread to request ownership of the mutex can handle this exception and proceed, if the integrity of the data structures can be verified.

시스템 차원 뮤텍스의 경우 중단된 뮤텍스는 애플리케이션이 갑자기 종료되었음을 나타낼 수 있습니다(예: Windows 작업 관리자를 사용하여).In the case of a system-wide mutex, an abandoned mutex might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager).

뮤텍스는 두 가지 유형이: 명명 되지 않은, 되 고 시스템 뮤텍스를 명명 된 로컬 뮤텍스입니다.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. 로컬 뮤텍스는 프로세스 내에만 존재합니다.A local mutex exists only within your process. 에 대 한 참조가 있는 프로세스의 모든 스레드에서 사용할 수는 Mutex 뮤텍스를 나타내는 개체입니다.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. 명명 되지 않은 각 Mutex 별도 로컬 뮤텍스 개체를 나타냅니다.Each unnamed Mutex object represents a separate local mutex.

명명 된 시스템 뮤텍스는 운영 체제 전체에서 볼 수 있으며 사용 하 여 프로세스 작업을 동기화 할 수 있습니다.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. 만들 수는 Mutex 이름을 허용 하는 생성자를 사용 하 여 명명된 된 시스템 뮤텍스를 나타내는 개체입니다.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. 동시에 운영 체제 개체를 만들 수 있습니다 또는 만들기 전에 존재할 수는 Mutex 개체입니다.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. 동일한 명명된 시스템 뮤텍스를 나타내는 여러 Mutex 개체를 만들 수 있으며 OpenExisting 메서드를 사용하여 기존 명명된 시스템 뮤텍스를 열 수 있습니다.You can create multiple Mutex objects that represent the same named system mutex, and you can use the OpenExisting method to open an existing named system mutex.

참고

터미널 서비스를 실행 하는 서버에서 명명된 된 시스템 뮤텍스는 두 가지 수준의 표시 유형 있습니다.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. 해당 이름 접두사로 시작 하는 경우 "Global\", 뮤텍스 모든 터미널 서버 세션에 표시 됩니다.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. 해당 이름 접두사로 시작 하는 경우 "로컬\", 뮤텍스 만들어진 터미널 서버 세션에만 표시 됩니다.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. 이 경우 각 서버에서 다른 터미널 서버 세션에서 동일한 이름 가진 별도 뮤텍스 존재할 수 있습니다.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. 명명된 된 뮤텍스를 만들 때 접두사를 지정 하지 않으면 접두사가 사용 "로컬\"입니다.If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". 터미널 서버 세션에서 이름이 해당 접두사만 다른 두 뮤텍스는 별도 뮤텍스 및 터미널 서버 세션에서 모든 프로세스에 표시 됩니다.Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. 즉, 접두사 이름을 "Global\" 및 "로컬\" 터미널 서버 세션을 기준으로, 프로세스 관련 되지 뮤텍스 이름 범위에 설명 합니다.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

백슬래시(\)는 뮤텍스 이름에 예약된 문자입니다.The backslash (\) is a reserved character in a mutex name. 터미널 서버 세션에서 뮤텍스 사용에 관한 노트에서 지정된 경우를 제외하고 뮤텍스 이름에 백슬래시(\)를 사용하지 마세요.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. 그렇지 않으면 뮤텍스의 이름이 기존 파일을 나타내더라도 DirectoryNotFoundException이 throw될 수 있습니다.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

생성자

Mutex() Mutex() Mutex() Mutex()

기본 속성을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean) Mutex(Boolean) Mutex(Boolean) Mutex(Boolean)

호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지 여부를 나타내는 부울 값을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex.

Mutex(Boolean, String) Mutex(Boolean, String) Mutex(Boolean, String) Mutex(Boolean, String)

호출 스레드가 뮤텍스의 초기 소유권을 가져야 할지 여부를 나타내는 부울 값과 뮤텍스 이름인 문자열을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex.

Mutex(Boolean, String, Boolean) Mutex(Boolean, String, Boolean) Mutex(Boolean, String, Boolean) Mutex(Boolean, String, Boolean)

호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지를 나타내는 부울 값을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

Mutex(Boolean, String, Boolean, MutexSecurity) Mutex(Boolean, String, Boolean, MutexSecurity) Mutex(Boolean, String, Boolean, MutexSecurity) Mutex(Boolean, String, Boolean, MutexSecurity)

호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지와 명명된 뮤텍스에 적용할 액세스 제어 보안을 나타내는 부울 변수를 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, a Boolean variable that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex, and the access control security to be applied to the named mutex.

메서드

Close() Close() Close() Close()

현재 WaitHandle에서 보유한 모든 리소스를 해제합니다.Releases all resources held by the current WaitHandle.

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

WaitHandle 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the current instance of the WaitHandle class.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

파생 클래스에서 재정의된 경우 WaitHandle에서 사용하는 관리되지 않는 리소스를 해제하고 필요에 따라 관리되는 리소스를 해제합니다.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Inherited from WaitHandle)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() GetAccessControl()

명명된 뮤텍스에 대한 액세스 제어 보안을 나타내는 MutexSecurity 개체를 가져옵니다.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OpenExisting(String) OpenExisting(String) OpenExisting(String) OpenExisting(String)

이미 있는 경우 지정한 명명된 뮤텍스를 엽니다.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights)

이미 있는 경우 지정한 명명된 뮤텍스를 원하는 보안 액세스로 엽니다.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex() ReleaseMutex() ReleaseMutex() ReleaseMutex()

Mutex을(를) 한 번 해제합니다.Releases the Mutex once.

SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity)

명명된 시스템 뮤텍스에 액세스 제어 보안을 설정합니다.Sets the access control security for a named system mutex.

ToString() ToString() ToString() ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(Inherited from Object)
TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex)

지정한 명명된 뮤텍스(이미 존재하는 경우)를 열고 작업이 수행되었는지를 나타내는 값을 반환합니다.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex)

지정된 명명된 뮤텍스를 원하는 보안 액세스 상태에서 열고 작업이 수행되었는지를 나타내는 값을 반환합니다.Opens the specified named mutex, if it already exists, with the desired security access, and returns a value that indicates whether the operation succeeded.

WaitOne() WaitOne() WaitOne() WaitOne()

현재 WaitHandle이(가) 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal.

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(Int32)

부호 있는 32비트 정수로 시간 간격(밀리초)을 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Inherited from WaitHandle)
WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean)

부호 있는 32비트 정수로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Inherited from WaitHandle)
WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

TimeSpan로 시간 간격을 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Inherited from WaitHandle)
WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean)

TimeSpan로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Inherited from WaitHandle)

속성

Handle Handle Handle Handle

네이티브 운영 체제 핸들을 가져오거나 설정합니다.Gets or sets the native operating system handle.

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

네이티브 운영 체제 핸들을 가져오거나 설정합니다.Gets or sets the native operating system handle.

(Inherited from WaitHandle)

명시적 인터페이스 구현

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

WaitHandle에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the WaitHandle.

(Inherited from WaitHandle)

필드

WaitTimeout WaitTimeout WaitTimeout WaitTimeout

대기 핸들이 신호를 받기 전에 WaitAny(WaitHandle[], Int32, Boolean) 작업이 제한 시간을 초과했음을 나타냅니다.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. 이 필드는 상수입니다.This field is constant.

(Inherited from WaitHandle)

확장 메서드

GetAccessControl(Mutex) GetAccessControl(Mutex) GetAccessControl(Mutex) GetAccessControl(Mutex)
SetAccessControl(Mutex, MutexSecurity) SetAccessControl(Mutex, MutexSecurity) SetAccessControl(Mutex, MutexSecurity) SetAccessControl(Mutex, MutexSecurity)
GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 가져옵니다.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 설정합니다.Sets a safe handle for a native operating system wait handle.

적용 대상

스레드 보안

이 형식은 스레드로부터 안전합니다.This type is thread safe.

추가 정보