Monitor.Enter 메서드

정의

네임스페이스:

System.Threading

어셈블리:

System.Threading.dll

지정된 개체의 단독 잠금을 가져옵니다.

오버로드

Enter(Object)	지정된 개체의 단독 잠금을 가져옵니다.
Enter(Object, Boolean)	지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정합니다.

Enter(Object)

Source:

Monitor.cs

지정된 개체의 단독 잠금을 가져옵니다.

public:
 static void Enter(System::Object ^ obj);

public static void Enter (object obj);

static member Enter : obj -> unit

Public Shared Sub Enter (obj As Object)

매개 변수

obj

Object

모니터 잠금을 가져올 개체입니다.

예외

ArgumentNullException

obj 매개 변수가 null인 경우

예제

다음 예제에서는 Enter 메서드를 사용하는 방법을 보여 줍니다.

#using <System.dll>

using namespace System;
using namespace System::Threading;
using namespace System::Collections::Generic;
using namespace System::Text;

generic <typename T> public ref class SafeQueue
{
private:
   // A queue that is protected by Monitor.
   Queue<T>^ m_inputQueue;

public:
   SafeQueue()
   {
      m_inputQueue = gcnew Queue<T>();
   };

   // Lock the queue and add an element.
   void Enqueue(T qValue)
   {
      // Request the lock, and block until it is obtained.
      Monitor::Enter(m_inputQueue);
      try
      {
         // When the lock is obtained, add an element.
         m_inputQueue->Enqueue(qValue);
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor::Exit(m_inputQueue);
      }
   };

   // Try to add an element to the queue: Add the element to the queue 
   // only if the lock is immediately available.
   bool TryEnqueue(T qValue)
   {
      // Request the lock.
      if (Monitor::TryEnter(m_inputQueue))
      {
         try
         {
            m_inputQueue->Enqueue(qValue);
         }
         finally
         {
            // Ensure that the lock is released.
            Monitor::Exit(m_inputQueue);
         }
         return true;
      }
      else
      {
         return false;
      }
   };

   // Try to add an element to the queue: Add the element to the queue 
   // only if the lock becomes available during the specified time
   // interval.
   bool TryEnqueue(T qValue, int waitTime)
   {
      // Request the lock.
      if (Monitor::TryEnter(m_inputQueue, waitTime))
      {
         try
         {
            m_inputQueue->Enqueue(qValue);
         }
         finally
         {
            // Ensure that the lock is released.
            Monitor::Exit(m_inputQueue);
         }
         return true;
      }
      else
      {
         return false;
      }
   };

   // Lock the queue and dequeue an element.
   T Dequeue()
   {
      T retval;

      // Request the lock, and block until it is obtained.
      Monitor::Enter(m_inputQueue);
      try
      {
         // When the lock is obtained, dequeue an element.
         retval = m_inputQueue->Dequeue();
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor::Exit(m_inputQueue);
      }

      return retval;
   };

   // Delete all elements that equal the given object.
   int Remove(T qValue)
   {
      int removedCt = 0;

      // Wait until the lock is available and lock the queue.
      Monitor::Enter(m_inputQueue);
      try
      {
         int counter = m_inputQueue->Count;
         while (counter > 0)
            // Check each element.
         {
            T elem = m_inputQueue->Dequeue();
            if (!elem->Equals(qValue))
            {
               m_inputQueue->Enqueue(elem);
            }
            else
            {
               // Keep a count of items removed.
               removedCt += 1;
            }
            counter = counter - 1;
         }
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor::Exit(m_inputQueue);
      }

      return removedCt;
   };

   // Print all queue elements.
   String^ PrintAllElements()
   {
      StringBuilder^ output = gcnew StringBuilder();

      // Lock the queue.
      Monitor::Enter(m_inputQueue);
      try
      {
         for each ( T elem in m_inputQueue )
         {
            // Print the next element.
            output->AppendLine(elem->ToString());
         }
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor::Exit(m_inputQueue);
      }

      return output->ToString();
   };
};

public ref class Example
{
private:
   static SafeQueue<int>^ q = gcnew SafeQueue<int>();
   static int threadsRunning = 0;
   static array<array<int>^>^ results = gcnew array<array<int>^>(3);

   static void ThreadProc(Object^ state)
   {
      DateTime finish = DateTime::Now.AddSeconds(10);
      Random^ rand = gcnew Random();
      array<int>^ result = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
      int threadNum = (int) state;

      while (DateTime::Now < finish)

      {
         int what = rand->Next(250);
         int how = rand->Next(100);

         if (how < 16)
         {
            q->Enqueue(what);
            result[(int)ThreadResultIndex::EnqueueCt] += 1;
         }
         else if (how < 32)
         {
            if (q->TryEnqueue(what))
            {
               result[(int)ThreadResultIndex::TryEnqueueSucceedCt] += 1;
            }
            else
            {
               result[(int)ThreadResultIndex::TryEnqueueFailCt] += 1;
            }
         }
         else if (how < 48)
         {
            // Even a very small wait significantly increases the success 
            // rate of the conditional enqueue operation.
            if (q->TryEnqueue(what, 10))
            {
               result[(int)ThreadResultIndex::TryEnqueueWaitSucceedCt] += 1;
            }
            else
            {
               result[(int)ThreadResultIndex::TryEnqueueWaitFailCt] += 1;
            }
         }
         else if (how < 96)
         {
            result[(int)ThreadResultIndex::DequeueCt] += 1;
            try
            {
               q->Dequeue();
            }
            catch (Exception^ ex)
            {
               result[(int)ThreadResultIndex::DequeueExCt] += 1;
            }
         }
         else
         {
            result[(int)ThreadResultIndex::RemoveCt] += 1;
            result[(int)ThreadResultIndex::RemovedCt] += q->Remove(what);
         }         
      }

      results[threadNum] = result;

      if (0 == Interlocked::Decrement(threadsRunning))      
      {
         StringBuilder^ sb = gcnew StringBuilder(
            "                               Thread 1 Thread 2 Thread 3    Total\n");

         for (int row = 0; row < 9; row++)
         {
            int total = 0;
            sb->Append(titles[row]);

            for(int col = 0; col < 3; col++)
            {
               sb->Append(String::Format("{0,9}", results[col][row]));
               total += results[col][row];
            }

            sb->AppendLine(String::Format("{0,9}", total));
         }

         Console::WriteLine(sb->ToString());
      }
   };

   static array<String^>^ titles = {
      "Enqueue                       ", 
      "TryEnqueue succeeded          ", 
      "TryEnqueue failed             ", 
      "TryEnqueue(T, wait) succeeded ", 
      "TryEnqueue(T, wait) failed    ", 
      "Dequeue attempts              ", 
      "Dequeue exceptions            ", 
      "Remove operations             ", 
      "Queue elements removed        "};

   enum class ThreadResultIndex
   {
      EnqueueCt, 
      TryEnqueueSucceedCt, 
      TryEnqueueFailCt, 
      TryEnqueueWaitSucceedCt, 
      TryEnqueueWaitFailCt, 
      DequeueCt, 
      DequeueExCt, 
      RemoveCt, 
      RemovedCt
   };

public:
   static void Demo()
   {
      Console::WriteLine("Working...");

      for(int i = 0; i < 3; i++)
      {
         Thread^ t = gcnew Thread(gcnew ParameterizedThreadStart(Example::ThreadProc));
         t->Start(i);
         Interlocked::Increment(threadsRunning);
      }
   };
};

void main()
{
   Example::Demo();
}


/* This example produces output similar to the following:

Working...
                               Thread 1 Thread 2 Thread 3    Total
Enqueue                          274718   513514   337895  1126127
TryEnqueue succeeded             274502   513516   337480  1125498
TryEnqueue failed                   119      235      141      495
TryEnqueue(T, wait) succeeded    274552   513116   338532  1126200
TryEnqueue(T, wait) failed            0        1        0        1
Dequeue attempts                 824038  1541866  1015006  3380910
Dequeue exceptions                12828    23416    14799    51043
Remove operations                 68746   128218    84306   281270
Queue elements removed            11464    22024    14470    47958
Queue elements removed            2921     4690     2982    10593
 */

using System;
using System.Threading;
using System.Collections.Generic;
using System.Text;

class SafeQueue<T>
{
   // A queue that is protected by Monitor.
   private Queue<T> m_inputQueue = new Queue<T>();

   // Lock the queue and add an element.
   public void Enqueue(T qValue)
   {
      // Request the lock, and block until it is obtained.
      Monitor.Enter(m_inputQueue);
      try
      {
         // When the lock is obtained, add an element.
         m_inputQueue.Enqueue(qValue);
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor.Exit(m_inputQueue);
      }
   }

   // Try to add an element to the queue: Add the element to the queue
   // only if the lock is immediately available.
   public bool TryEnqueue(T qValue)
   {
      // Request the lock.
      if (Monitor.TryEnter(m_inputQueue))
      {
         try
         {
            m_inputQueue.Enqueue(qValue);
         }
         finally
         {
            // Ensure that the lock is released.
            Monitor.Exit(m_inputQueue);
         }
         return true;
      }
      else
      {
         return false;
      }
   }

   // Try to add an element to the queue: Add the element to the queue
   // only if the lock becomes available during the specified time
   // interval.
   public bool TryEnqueue(T qValue, int waitTime)
   {
      // Request the lock.
      if (Monitor.TryEnter(m_inputQueue, waitTime))
      {
         try
         {
            m_inputQueue.Enqueue(qValue);
         }
         finally
         {
            // Ensure that the lock is released.
            Monitor.Exit(m_inputQueue);
         }
         return true;
      }
      else
      {
         return false;
      }
   }

   // Lock the queue and dequeue an element.
   public T Dequeue()
   {
      T retval;

      // Request the lock, and block until it is obtained.
      Monitor.Enter(m_inputQueue);
      try
      {
         // When the lock is obtained, dequeue an element.
         retval = m_inputQueue.Dequeue();
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor.Exit(m_inputQueue);
      }

      return retval;
   }

   // Delete all elements that equal the given object.
   public int Remove(T qValue)
   {
      int removedCt = 0;

      // Wait until the lock is available and lock the queue.
      Monitor.Enter(m_inputQueue);
      try
      {
         int counter = m_inputQueue.Count;
         while (counter > 0)
            // Check each element.
         {
            T elem = m_inputQueue.Dequeue();
            if (!elem.Equals(qValue))
            {
               m_inputQueue.Enqueue(elem);
            }
            else
            {
               // Keep a count of items removed.
               removedCt += 1;
            }
            counter = counter - 1;
         }
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor.Exit(m_inputQueue);
      }

      return removedCt;
   }

   // Print all queue elements.
   public string PrintAllElements()
   {
      StringBuilder output = new StringBuilder();

      // Lock the queue.
      Monitor.Enter(m_inputQueue);
      try
      {
         foreach( T elem in m_inputQueue )
         {
            // Print the next element.
            output.AppendLine(elem.ToString());
         }
      }
      finally
      {
         // Ensure that the lock is released.
         Monitor.Exit(m_inputQueue);
      }

      return output.ToString();
   }
}

public class Example
{
   private static SafeQueue<int> q = new SafeQueue<int>();
   private static int threadsRunning = 0;
   private static int[][] results = new int[3][];

   static void Main()
   {
      Console.WriteLine("Working...");

      for(int i = 0; i < 3; i++)
      {
         Thread t = new Thread(ThreadProc);
         t.Start(i);
         Interlocked.Increment(ref threadsRunning);
      }
   }

   private static void ThreadProc(object state)
   {
      DateTime finish = DateTime.Now.AddSeconds(10);
      Random rand = new Random();
      int[] result = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
      int threadNum = (int) state;

      while (DateTime.Now < finish)

      {
         int what = rand.Next(250);
         int how = rand.Next(100);

         if (how < 16)
         {
            q.Enqueue(what);
            result[(int)ThreadResultIndex.EnqueueCt] += 1;
         }
         else if (how < 32)
         {
            if (q.TryEnqueue(what))
            {
               result[(int)ThreadResultIndex.TryEnqueueSucceedCt] += 1;
            }
            else
            {
               result[(int)ThreadResultIndex.TryEnqueueFailCt] += 1;
            }
         }
         else if (how < 48)
         {
            // Even a very small wait significantly increases the success
            // rate of the conditional enqueue operation.
            if (q.TryEnqueue(what, 10))
            {
               result[(int)ThreadResultIndex.TryEnqueueWaitSucceedCt] += 1;
            }
            else
            {
               result[(int)ThreadResultIndex.TryEnqueueWaitFailCt] += 1;
            }
         }
         else if (how < 96)
         {
            result[(int)ThreadResultIndex.DequeueCt] += 1;
            try
            {
               q.Dequeue();
            }
            catch
            {
               result[(int)ThreadResultIndex.DequeueExCt] += 1;
            }
         }
         else
         {
            result[(int)ThreadResultIndex.RemoveCt] += 1;
            result[(int)ThreadResultIndex.RemovedCt] += q.Remove(what);
         }
      }

      results[threadNum] = result;

      if (0 == Interlocked.Decrement(ref threadsRunning))
      {
         StringBuilder sb = new StringBuilder(
            "                               Thread 1 Thread 2 Thread 3    Total\n");

         for(int row = 0; row < 9; row++)
         {
            int total = 0;
            sb.Append(titles[row]);

            for(int col = 0; col < 3; col++)
            {
               sb.Append(String.Format("{0,9}", results[col][row]));
               total += results[col][row];
            }

            sb.AppendLine(String.Format("{0,9}", total));
         }

         Console.WriteLine(sb.ToString());
      }
   }

   private static string[] titles = {
      "Enqueue                       ",
      "TryEnqueue succeeded          ",
      "TryEnqueue failed             ",
      "TryEnqueue(T, wait) succeeded ",
      "TryEnqueue(T, wait) failed    ",
      "Dequeue attempts              ",
      "Dequeue exceptions            ",
      "Remove operations             ",
      "Queue elements removed        "};

   private enum ThreadResultIndex
   {
      EnqueueCt,
      TryEnqueueSucceedCt,
      TryEnqueueFailCt,
      TryEnqueueWaitSucceedCt,
      TryEnqueueWaitFailCt,
      DequeueCt,
      DequeueExCt,
      RemoveCt,
      RemovedCt
   };
}

/* This example produces output similar to the following:

Working...
                               Thread 1 Thread 2 Thread 3    Total
Enqueue                          277382   515209   308464  1101055
TryEnqueue succeeded             276873   514621   308099  1099593
TryEnqueue failed                   109      181      134      424
TryEnqueue(T, wait) succeeded    276913   514434   307607  1098954
TryEnqueue(T, wait) failed            2        0        0        2
Dequeue attempts                 830980  1544081   924164  3299225
Dequeue exceptions                12102    21589    13539    47230
Remove operations                 69550   129479    77351   276380
Queue elements removed            11957    22572    13043    47572
 */

Imports System.Threading
Imports System.Collections.Generic
Imports System.Text

Class SafeQueue(Of T)

   ' A queue that is protected by Monitor.
   Private m_inputQueue As New Queue(Of T)

   ' Lock the queue and add an element.
   Public Sub Enqueue(ByVal qValue As T)

      ' Request the lock, and block until it is obtained.
      Monitor.Enter(m_inputQueue)
      Try
         ' When the lock is obtained, add an element.
         m_inputQueue.Enqueue(qValue)

      Finally
         ' Ensure that the lock is released.
         Monitor.Exit(m_inputQueue)
      End Try
   End Sub

   ' Try to add an element to the queue: Add the element to the queue 
   ' only if the lock is immediately available.
   Public Function TryEnqueue(ByVal qValue As T) As Boolean

      ' Request the lock.
      If Monitor.TryEnter(m_inputQueue) Then
         Try
            m_inputQueue.Enqueue(qValue)

         Finally
            ' Ensure that the lock is released.
            Monitor.Exit(m_inputQueue)
         End Try
         Return True
      Else
         Return False
      End If
   End Function

   ' Try to add an element to the queue: Add the element to the queue 
   ' only if the lock becomes available during the specified time
   ' interval.
   Public Function TryEnqueue(ByVal qValue As T, ByVal waitTime As Integer) As Boolean

      ' Request the lock.
      If Monitor.TryEnter(m_inputQueue, waitTime) Then
         Try
            m_inputQueue.Enqueue(qValue)

         Finally
            ' Ensure that the lock is released.
            Monitor.Exit(m_inputQueue)
         End Try
         Return True
      Else
         Return False
      End If
   End Function

   ' Lock the queue and dequeue an element.
   Public Function Dequeue() As T

      Dim retval As T

      ' Request the lock, and block until it is obtained.
      Monitor.Enter(m_inputQueue)
      Try
         ' When the lock is obtained, dequeue an element.
         retval = m_inputQueue.Dequeue()

      Finally
         ' Ensure that the lock is released.
         Monitor.Exit(m_inputQueue)
      End Try

      Return retval
   End Function

   ' Delete all elements that equal the given object.
   Public Function Remove(ByVal qValue As T) As Integer

      Dim removedCt As Integer = 0

      ' Wait until the lock is available and lock the queue.
      Monitor.Enter(m_inputQueue)
      Try
         Dim counter As Integer = m_inputQueue.Count
         While (counter > 0)
            'Check each element.
            Dim elem As T = m_inputQueue.Dequeue()
            If Not elem.Equals(qValue) Then
               m_inputQueue.Enqueue(elem)
            Else
               ' Keep a count of items removed.
               removedCt += 1
            End If
            counter = counter - 1
         End While

      Finally
         ' Ensure that the lock is released.
         Monitor.Exit(m_inputQueue)
      End Try

      Return removedCt
   End Function

   ' Print all queue elements.
   Public Function PrintAllElements() As String

      Dim output As New StringBuilder()

      'Lock the queue.
      Monitor.Enter(m_inputQueue)
      Try
         For Each elem As T In m_inputQueue
            ' Print the next element.
            output.AppendLine(elem.ToString())
         Next

      Finally
         ' Ensure that the lock is released.
         Monitor.Exit(m_inputQueue)
      End Try

      Return output.ToString()
   End Function
End Class

Public Class Example

   Private Shared q As New SafeQueue(Of Integer)
   Private Shared threadsRunning As Integer = 0
   Private Shared results(2)() As Integer

   Friend Shared Sub Main()

      Console.WriteLine("Working...")

      For i As Integer = 0 To 2

         Dim t As New Thread(AddressOf ThreadProc)
         t.Start(i)
         Interlocked.Increment(threadsRunning)

      Next i

   End Sub

   Private Shared Sub ThreadProc(ByVal state As Object)

      Dim finish As DateTime = DateTime.Now.AddSeconds(10)
      Dim rand As New Random()
      Dim result() As Integer = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
      Dim threadNum As Integer = CInt(state)

      While (DateTime.Now < finish)

         Dim what As Integer = rand.Next(250)
         Dim how As Integer = rand.Next(100)

         If how < 16 Then
            q.Enqueue(what)
            result(ThreadResultIndex.EnqueueCt) += 1
         Else If how < 32 Then
            If q.TryEnqueue(what)
               result(ThreadResultIndex.TryEnqueueSucceedCt) += 1
            Else
               result(ThreadResultIndex.TryEnqueueFailCt) += 1
            End If
         Else If how < 48 Then
            ' Even a very small wait significantly increases the success 
            ' rate of the conditional enqueue operation.
            If q.TryEnqueue(what, 10)
               result(ThreadResultIndex.TryEnqueueWaitSucceedCt) += 1
            Else
               result(ThreadResultIndex.TryEnqueueWaitFailCt) += 1
            End If
         Else If how < 96 Then
            result(ThreadResultIndex.DequeueCt) += 1
            Try
               q.Dequeue()
            Catch
               result(ThreadResultIndex.DequeueExCt) += 1
            End Try
         Else
            result(ThreadResultIndex.RemoveCt) += 1
            result(ThreadResultIndex.RemovedCt) += q.Remove(what)
         End If
         
      End While

      results(threadNum) = result

      If 0 = Interlocked.Decrement(threadsRunning) Then
      
         Dim sb As New StringBuilder( _
            "                               Thread 1 Thread 2 Thread 3    Total" & vbLf)

         For row As Integer = 0 To 8

            Dim total As Integer = 0
            sb.Append(titles(row))

            For col As Integer = 0 To 2

               sb.Append(String.Format("{0,9}", results(col)(row)))
               total += results(col)(row)

            Next col

            sb.AppendLine(String.Format("{0,9}", total))

         Next row

         Console.WriteLine(sb.ToString())

      End If     
    
   End Sub

   Private Shared titles() As String = { _
      "Enqueue                       ", _
      "TryEnqueue succeeded          ", _
      "TryEnqueue failed             ", _
      "TryEnqueue(T, wait) succeeded ", _
      "TryEnqueue(T, wait) failed    ", _
      "Dequeue attempts              ", _
      "Dequeue exceptions            ", _
      "Remove operations             ", _
      "Queue elements removed        "  _
   }

   Private Enum ThreadResultIndex
      EnqueueCt
      TryEnqueueSucceedCt
      TryEnqueueFailCt
      TryEnqueueWaitSucceedCt
      TryEnqueueWaitFailCt
      DequeueCt
      DequeueExCt
      RemoveCt
      RemovedCt
   End Enum

End Class

' This example produces output similar to the following:
'
'Working...
'                               Thread 1 Thread 2 Thread 3    Total
'Enqueue                          294357   512164   302838  1109359
'TryEnqueue succeeded             294486   512403   303117  1110006
'TryEnqueue failed                   108      234      127      469
'TryEnqueue(T, wait) succeeded    294259   512796   302556  1109611
'TryEnqueue(T, wait) failed            1        1        1        3
'Dequeue attempts                 882266  1537993   907795  3328054
'Dequeue exceptions                12691    21474    13480    47645
'Remove operations                 74059   128715    76187   278961
'Queue elements removed            12667    22606    13219    48492

설명

를 사용하여 Enter 매개 변수로 전달된 개체의 를 가져옵니다 Monitor . 다른 스레드가 개체에서 를 Enter 실행했지만 해당 Exit를 아직 실행하지 않은 경우 다른 스레드가 개체를 해제할 때까지 현재 스레드가 차단됩니다. 동일한 스레드가 차단하지 않고 두 번 이상 호출 Enter 하는 것은 합법적이지만 개체를 기다리는 다른 스레드가 차단을 해제하기 전에 동일한 수의 Exit 호출을 호출해야 합니다.

를 사용하여 Monitor 값 형식이 아닌 개체(즉, 참조 형식)를 잠급니다. 값 형식 변수를 에 Enter전달하면 개체로 boxed됩니다. 동일한 변수를 Enter 에 다시 전달하면 별도의 개체로 boxed되고 스레드가 차단되지 않습니다. 이 경우 보호한다고 가정 Monitor 하는 코드는 보호되지 않습니다. 또한 변수를 에 Exit전달하면 다른 별도의 개체가 만들어집니다. 에 전달된 개체가 에 Exit 전달된 개체와 다르기 EnterMonitor 때문에 은 을 throw합니다SynchronizationLockException. 자세한 내용은 개념 항목 모니터를 참조하세요.

Interrupt 는 개체에 를 입력하기 위해 대기 중인 스레드를 Monitor 중단할 수 있습니다. 가 ThreadInterruptedException throw됩니다.

C# try사용...finally 블록(TryVisual Basic에서는...Finally )을 사용하여 모니터를 해제하거나 및 메서드를 로 래핑하는 C# lock 문(SyncLock Visual Basic의 EnterExit 문)을 try사용합니다.finally 블록.

추가 정보

• Thread
• Monitor
• 관리되는 스레딩

Enter(Object, Boolean)

Source:

Monitor.CoreCLR.cs

지정된 개체의 단독 잠금을 가져오고 잠금 설정 여부를 나타내는 값을 자동으로 설정합니다.

public:
 static void Enter(System::Object ^ obj, bool % lockTaken);

public static void Enter (object obj, ref bool lockTaken);

static member Enter : obj * bool -> unit

Public Shared Sub Enter (obj As Object, ByRef lockTaken As Boolean)

매개 변수

obj

Object

대기할 개체입니다.

lockTaken

Boolean

잠금을 얻기 위한 시도의 결과로서, 참조에 의해 전달됩니다. 입력은 false여야 합니다. 잠금을 얻으면 출력이 true이고, 그렇지 않으면 출력이 false입니다. 잠금을 얻으려는 시도 도중에 예외가 발생해도 출력이 설정됩니다.

참고 예외가 발생하지 않으면 이 메서드의 출력은 항상 true입니다.

예외

ArgumentException

lockTaken에 대한 입력이 true인 경우

ArgumentNullException

obj 매개 변수가 null인 경우

예제

다음 코드에서는 메서드 오버로드를 사용하기 Enter(Object, Boolean) 위한 기본 패턴을 보여 줍니다. 이 오버로드는 메서드가 예외를 ref throw하더라도 매개 변수(ByRef Visual Basic의 경우) lockTaken에 전달되는 변수의 값을 항상 설정하므로 변수 값은 잠금을 해제해야 하는지 여부를 테스트하는 신뢰할 수 있는 방법입니다.

bool acquiredLock = false;

try
{
    Monitor.Enter(lockObject, ref acquiredLock);

    // Code that accesses resources that are protected by the lock.
}
finally
{
    if (acquiredLock)
    {
        Monitor.Exit(lockObject);
    }
}

Dim acquiredLock As Boolean = False

Try
    Monitor.Enter(lockObject, acquiredLock)

    ' Code that accesses resources that are protected by the lock.

Finally
    If acquiredLock Then
        Monitor.Exit(lockObject)
    End If
End Try

설명

를 사용하여 Enter 매개 변수로 전달된 개체의 를 obj 가져옵니다Monitor. 다른 스레드가 개체에서 를 Enter 실행했지만 해당 Exit를 아직 실행하지 않은 경우 다른 스레드가 개체를 해제할 때까지 현재 스레드가 차단됩니다. 동일한 스레드가 차단하지 않고 두 번 이상 호출 Enter 하는 것은 합법적이지만 개체를 기다리는 다른 스레드가 차단을 해제하기 전에 동일한 수의 Exit 호출을 호출해야 합니다.

예외가 throw되어 잠금이 수행되지 않은 경우 매개 변수에 지정된 lockTaken 변수는 이 메서드가 종료된 후입니다 false . 이렇게 하면 프로그램에서 모든 경우에 잠금을 해제해야 하는지 여부를 확인할 수 있습니다. 이 메서드가 예외를 throw하지 않고 반환하는 경우 매개 변수에 지정된 lockTaken 변수는 항상 true이며 테스트할 필요가 없습니다.

를 사용하여 Monitor 값 형식이 아닌 개체(즉, 참조 형식)를 잠급니다. 값 형식 변수를 에 Enter전달하면 개체로 boxed됩니다. 동일한 변수를 Enter 에 다시 전달하면 별도의 개체로 boxed되고 스레드가 차단되지 않습니다. 이 경우 보호한다고 가정 Monitor 하는 코드는 보호되지 않습니다. 또한 변수를 에 Exit전달하면 다른 별도의 개체가 만들어집니다. 에 전달된 개체가 에 Exit 전달된 개체와 다르기 EnterMonitor 때문에 은 을 throw합니다SynchronizationLockException. 자세한 내용은 개념 항목 모니터를 참조하세요.

Interrupt 는 개체에 를 입력하기 위해 대기 중인 스레드를 Monitor 중단할 수 있습니다. 가 ThreadInterruptedException throw됩니다.