이 문서는 기계 번역을 이용하여 번역되었습니다. 문서를 영문으로 보려면 영문 확인란을 선택하세요. 마우스 포인터를 텍스트 위로 이동시켜 팝업 창에서 영문 텍스트를 표시할 수도 있습니다.
번역
영문

Mutex 클래스

 

게시 날짜: 2016년 11월

프로세스 간 동기화에 사용할 수도 있는 동기화 기본 형식입니다.

네임스페이스:   System.Threading
어셈블리:  mscorlib(mscorlib.dll에 있음)

System.Object
  System.MarshalByRefObject
    System.Threading.WaitHandle
      System.Threading.Mutex

[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public sealed class Mutex : WaitHandle

이름설명
System_CAPS_pubmethodMutex()

기본 속성을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.

System_CAPS_pubmethodMutex(Boolean)

호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.

System_CAPS_pubmethodMutex(Boolean, String)

호출 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값과 뮤텍스 이름인 문자열을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.

System_CAPS_pubmethodMutex(Boolean, String, Boolean)

호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지를 나타내는 부울 값을 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.

System_CAPS_pubmethodMutex(Boolean, String, Boolean, MutexSecurity)

호출한 스레드가 뮤텍스의 초기 소유권을 가져야 할지를 나타내는 부울 값, 뮤텍스의 이름인 문자열 및 메서드에서 반환할 때 호출한 스레드에 뮤텍스의 초기 소유권이 부여되었는지와 명명된 뮤텍스에 적용할 액세스 제어 보안을 나타내는 부울 변수를 사용하여 Mutex 클래스의 새 인스턴스를 초기화합니다.

이름설명
System_CAPS_pubpropertyHandle

사용되지 않습니다. 네이티브 운영 체제 핸들을 가져오거나 설정합니다.(WaitHandle에서 상속됨)

System_CAPS_pubpropertySafeWaitHandle

네이티브 운영 체제 핸들을 가져오거나 설정합니다.(WaitHandle에서 상속됨)

이름설명
System_CAPS_pubmethodClose()

현재 WaitHandle 에서 보유한 모든 리소스를 해제합니다.(WaitHandle에서 상속됨)

System_CAPS_pubmethodCreateObjRef(Type)

원격 개체와 통신 하는 데 프록시를 생성 하는 데 필요한 모든 관련 정보를 포함 하는 개체를 만듭니다.(MarshalByRefObject에서 상속됨)

System_CAPS_pubmethodDispose()

WaitHandle 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.(WaitHandle에서 상속됨)

System_CAPS_pubmethodEquals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.(Object에서 상속됨)

System_CAPS_pubmethodGetAccessControl()

명명된 뮤텍스에 대한 액세스 제어 보안을 나타내는 MutexSecurity 개체를 가져옵니다.

System_CAPS_pubmethodGetHashCode()

기본 해시 함수로 작동합니다.(Object에서 상속됨)

System_CAPS_pubmethodGetLifetimeService()

이 인스턴스에 대 한 수명 정책을 제어 하는 수명이 현재 서비스 개체를 검색 합니다.(MarshalByRefObject에서 상속됨)

System_CAPS_pubmethodGetType()

현재 인스턴스의 Type을 가져옵니다.(Object에서 상속됨)

System_CAPS_pubmethodInitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.(MarshalByRefObject에서 상속됨)

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String)

이미 있는 경우 지정한 명명된 뮤텍스를 엽니다.

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String, MutexRights)

이미 있는 경우 지정한 명명된 뮤텍스를 원하는 보안 액세스로 엽니다.

System_CAPS_pubmethodReleaseMutex()

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

System_CAPS_pubmethodSetAccessControl(MutexSecurity)

명명된 시스템 뮤텍스에 액세스 제어 보안을 설정합니다.

System_CAPS_pubmethodToString()

현재 개체를 나타내는 문자열을 반환합니다.(Object에서 상속됨)

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, Mutex)

지정한 명명된 뮤텍스(이미 존재하는 경우)를 열고 작업이 수행되었는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, MutexRights, Mutex)

지정된 명명된 뮤텍스를 원하는 보안 액세스 상태에서 열고 작업이 수행되었는지를 나타내는 값을 반환합니다.

System_CAPS_pubmethodWaitOne()

현재 WaitHandle이(가) 신호를 받을 때까지 현재 스레드를 차단합니다.(WaitHandle에서 상속됨)

System_CAPS_pubmethodWaitOne(Int32)

부호 있는 32비트 정수로 시간 간격(밀리초)을 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.(WaitHandle에서 상속됨)

System_CAPS_pubmethodWaitOne(Int32, Boolean)

부호 있는 32비트 정수로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.(WaitHandle에서 상속됨)

System_CAPS_pubmethodWaitOne(TimeSpan)

TimeSpan로 시간 간격을 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.(WaitHandle에서 상속됨)

System_CAPS_pubmethodWaitOne(TimeSpan, Boolean)

TimeSpan로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.(WaitHandle에서 상속됨)

이름설명
System_CAPS_pubmethodGetSafeWaitHandle()

네이티브 운영 체제 대기 핸들에 대 한 안전한 핸들을 가져옵니다.(WaitHandleExtensions에서 정의됨)

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

네이티브 운영 체제 대기 핸들에 대 한 안전한 핸들을 설정합니다.(WaitHandleExtensions에서 정의됨)

System_CAPS_note참고

이 유형에 대 한.NET Framework 소스 코드를 보려면 참조는 Reference Source합니다. 온라인 소스 코드, 오프 라인으로 보기에 대 한 참조를 다운로드 및 디버깅 하는 동안 소스 (패치 및 업데이트 포함)를 단계별로 실행 합니다. see instructions.

두 개 이상의 스레드를 동시에 공유 리소스에 액세스 해야 하는 경우 시스템 리소스를 한 번에 하나의 스레드만 사용을 보장 하는 동기화 메커니즘이 필요 합니다. Mutex 단일 스레드에 맞게 공유 리소스에 대 한 단독 액세스를 부여 하는 기본 동기화 합니다. 스레드가 뮤텍스를 구입 하는 경우 두 번째 스레드는 뮤텍스를 획득 하는 첫 번째 스레드가 뮤텍스를 해제할 때까지 일시 중단 됩니다.

System_CAPS_important중요

이 형식에서 구현 하는 IDisposable 인터페이스입니다. 형식을 사용 하 여 했으면 삭제 해야의 직접 또는 간접적으로. 직접 형식의 dispose를 호출 하는 Dispose 에서 메서드는 try/catch 블록입니다. 작업을 삭제할 하지 직접,를 사용 하 여 언어 구문와 같은 using (in C#) 또는 Using (Visual Basic에서는). 자세한 내용은 참조 "를 사용 하는 개체는 구현 IDisposable" 섹션에는 IDisposable 인터페이스 항목입니다.

사용할 수는 WaitHandle.WaitOne 뮤텍스의 소유권을 요청 하는 방법입니다. 해당 호출 스레드는 차단 다음 중 하나가 발생할 때까지:

  • 뮤텍스를 소유 하지 않은 나타내는 신호 됩니다. 이 경우는 WaitOne 메서드 반환 true, 호출 스레드가 뮤텍스의 소유권을 가정 하 고는 뮤텍스로 보호 되는 리소스에 액세스 하 고 있습니다. 리소스에 액세스 완료 될 때 스레드를 호출 해야는 ReleaseMutex 메서드를 뮤텍스의 소유권을 해제 합니다. 예제 단원의 첫 번째 예제에서는이 패턴을 보여 줍니다.

  • 에 대 한 호출에 지정 된 시간 제한 간격은 WaitOne 변수가 있는 메서드에 millisecondsTimeout 또는 timeout 매개 변수가 있습니다. 이 경우는 WaitOne 메서드가 반환한 false, 및 호출 스레드가 뮤텍스의 소유권 획득 하기 위해 더 이상 시도 하지 않습니다. 이 경우 호출 스레드에 뮤텍스로 보호 되는 리소스에 대 한 액세스 거부 되었습니다 되도록 코드를 구성 해야 합니다. 호출 하지 해야 했기 때문에 스레드가 없습니다 뮤텍스의 소유권을는 ReleaseMutex 메서드. 예 섹션에 두 번째 예제에서는이 패턴을 보여 줍니다.

Mutex 를 가져온 스레드에서만 뮤텍스를 해제 될 수 있으므로 클래스는 스레드 id를 적용 합니다. 이와 반대로 Semaphore 클래스는 스레드 id를 적용 하지 않습니다. 뮤텍스는 응용 프로그램 도메인 경계를 넘어 전달할 수도 있습니다.

뮤텍스를 소유 하는 스레드를 반복 해 서 호출에 같은 뮤텍스를 요청할 수 WaitOne 실행을 차단 하지 않고 있습니다. 하지만 스레드를 호출 해야는 ReleaseMutex 메서드 뮤텍스의 소유권을 해제 하려면 동일한 횟수입니다.

때문에 Mutex 클래스에서 상속 WaitHandle, 정적 호출할 수도 있습니다 WaitHandle.WaitAllWaitHandle.WaitAny 보호 된 리소스에 대 한 액세스를 동기화 하는 메서드.

스레드가 뮤텍스를 소유 하는 동안 종료 하는 경우 중단 된 뮤텍스 이라고 합니다. 신호를 받는 뮤텍스의 상태 설정 되 고 대기 중인 다음 스레드가 소유권을 가져옵니다. .NET Framework 버전 2.0 부터는 AbandonedMutexException 중단 된 뮤텍스를 획득 하는 다음 스레드에서 예외가 발생 합니다. .NET Framework 버전 2.0 이전의 예외가 throw 되었습니다.

System_CAPS_caution주의

중단 된 뮤텍스는 종종 코드의 심각한 오류를 나타냅니다. 않을 스레드가 뮤텍스를 해제 하지 않고 종료 되 면 뮤텍스의 보호를 받는 데이터 구조는 일관에서 되지 수 있습니다. 뮤텍스의 소유권을 요청 하는 다음 스레드에서이 예외를 처리 하 고 데이터 구조의 무결성을 확인할 수 있으면 진행할 수 있습니다.

시스템 차원의 뮤텍스를 중단 된 뮤텍스 (예를 들어 사용 하 여 Windows 작업 관리자) 응용 프로그램이 갑자기 종료 되었습니다 나타낼 수 있습니다.

뮤텍스는 두 가지 유형의: 명명 되지 않은 되어 시스템 뮤텍스를 명명 된 로컬 뮤텍스 합니다. 로컬 뮤텍스는 프로세스 내에 존재합니다. 에 대 한 참조 프로세스의 모든 스레드에서 사용할 수는 Mutex 뮤텍스를 나타내는 개체입니다. 명명 되지 않은 각 Mutex 개체는 별도 로컬 뮤텍스를 나타냅니다.

명명 된 시스템 뮤텍스는 운영 체제 전체에서 볼 수 있으며 프로세스 작업을 동기화 할 수 있습니다. 만들 수는 Mutex 이름을 허용 하는 생성자를 사용 하 여 명명된 된 시스템 뮤텍스를 나타내는 개체입니다. 같은 시간에 운영 체제 개체를 만들 수 있습니다 하거나 만들기 전에 존재할 수 있는 Mutex 개체입니다. 여러 개 만들 수 있습니다 Mutex 동일한 나타내는 개체를 명명 된 시스템 뮤텍스를 하 고 사용할 수는 OpenExisting 메서드를 기존 명명 된 시스템 뮤텍스가 합니다.

System_CAPS_note참고

터미널 서비스를 실행 하는 서버를 명명된 된 시스템 뮤텍스 두 가지 수준의 표시 유형 있을 수 있습니다. 이름이 "Global\" 접두사로 시작 되 면 뮤텍스의 모든 터미널 서버 세션에 표시 됩니다. 이름이 "로컬 \" 접두사로 시작 되 면 뮤텍스의 만들어진 터미널 서버 세션에만 표시 됩니다. 이 경우 같은 이름의 뮤텍스 별도 각 서버에서 다른 터미널 서버 세션에 있을 수 있습니다. 명명된 된 뮤텍스를 만들 때 접두사를 지정 하지 않으면 접두사 "로컬" \ 걸립니다. 터미널 서버 세션에서 이름이 해당 접두사만 다른 두 뮤텍스는 별개의 뮤텍스이며 및 둘 다 터미널 서버 세션에서 모든 프로세스에 표시 됩니다. 즉, 접두사 이름 "Global\" 및 "로컬 \" 프로세스 관련 되지 않은 터미널 서버 세션을 기준으로 뮤텍스 이름의 범위에 설명 합니다.

이 예에서는 로컬 방법을 Mutex 개체는 보호 된 리소스에 대 한 액세스를 동기화 하는 데 사용 됩니다. 호출 해야 하므로 각 호출 스레드가 뮤텍스의 소유권을 가져올 때까지 차단 되는 ReleaseMutex 스레드가 소유권을 해제 하려면 메서드.

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

다음 예제에서는 각 스레드의 호출는 WaitOne(Int32) 메서드를 뮤텍스를 획득 합니다. 메서드가 반환 하는 경우 시간 제한 간격이 경과 하면 false, 스레드가 뮤텍스를 획득 아니고 뮤텍스의 보호 된 리소스에 액세스 하 고 있습니다. ReleaseMutex 메서드만 뮤텍스를 획득 하는 스레드에 의해 호출 됩니다.

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

유니버설 Windows 플랫폼
8 이후 사용 가능
.NET Framework
1.1 이후 사용 가능
이식 가능한 클래스 라이브러리
이식 가능한 .NET 플랫폼 에서 지원됨
Windows Phone Silverlight
7.1 이후 사용 가능
Windows Phone
8.1 이후 사용 가능

이 형식은 스레드로부터 안전합니다.

맨 위로 이동
표시: