Monitor.TryEnter Monitor.TryEnter Monitor.TryEnter Monitor.TryEnter Method

定義

嘗試取得指定物件的獨佔鎖定。Attempts to acquire an exclusive lock on the specified object.

多載

TryEnter(Object, TimeSpan, Boolean) TryEnter(Object, TimeSpan, Boolean) TryEnter(Object, TimeSpan, Boolean) TryEnter(Object, TimeSpan, Boolean)

嘗試在指定的時間內取得指定之物件的獨佔鎖定,並且完整設定值,指出是否採用鎖定。Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken.

TryEnter(Object, Int32, Boolean) TryEnter(Object, Int32, Boolean) TryEnter(Object, Int32, Boolean) TryEnter(Object, Int32, Boolean)

嘗試在指定的毫秒數內取得指定之物件的獨佔鎖定,並且完整設定值,指出是否採用鎖定。Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken.

TryEnter(Object, TimeSpan) TryEnter(Object, TimeSpan) TryEnter(Object, TimeSpan) TryEnter(Object, TimeSpan)

嘗試取得指定物件的獨佔鎖定 (在指定的時間內)。Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object.

TryEnter(Object, Boolean) TryEnter(Object, Boolean) TryEnter(Object, Boolean) TryEnter(Object, Boolean)

嘗試取得指定之物件的獨佔鎖定,並且完整設定值,指出是否採用鎖定。Attempts to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken.

TryEnter(Object) TryEnter(Object) TryEnter(Object) TryEnter(Object)

嘗試取得指定物件的獨佔鎖定。Attempts to acquire an exclusive lock on the specified object.

TryEnter(Object, Int32) TryEnter(Object, Int32) TryEnter(Object, Int32) TryEnter(Object, Int32)

嘗試取得指定物件的獨佔鎖定 (在指定的毫秒數時間內)。Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object.

TryEnter(Object, TimeSpan, Boolean) TryEnter(Object, TimeSpan, Boolean) TryEnter(Object, TimeSpan, Boolean) TryEnter(Object, TimeSpan, Boolean)

嘗試在指定的時間內取得指定之物件的獨佔鎖定,並且完整設定值,指出是否採用鎖定。Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken.

public:
 static void TryEnter(System::Object ^ obj, TimeSpan timeout, bool % lockTaken);
public static void TryEnter (object obj, TimeSpan timeout, ref bool lockTaken);
static member TryEnter : obj * TimeSpan *  -> unit
Public Shared Sub TryEnter (obj As Object, timeout As TimeSpan, ByRef lockTaken As Boolean)

參數

obj
Object Object Object Object

要取得鎖定的物件。The object on which to acquire the lock.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

等候鎖定的時間長度。The amount of time to wait for the lock. -1 毫秒的值會指定無限期等候。A value of -1 millisecond specifies an infinite wait.

lockTaken
Boolean Boolean Boolean Boolean

嘗試取得鎖定的結果 (以傳址方式傳遞)。The result of the attempt to acquire the lock, passed by reference. 輸入必須是 falseThe input must be false. 如果已取得鎖定,輸出就是 true;否則輸出為 falseThe output is true if the lock is acquired; otherwise, the output is false. 嘗試取得鎖定期間,即使發生例外狀況,仍然會設定輸出。The output is set even if an exception occurs during the attempt to acquire the lock.

例外狀況

lockTaken 的輸入為 trueThe input to lockTaken is true.

timeout 的毫秒值為負值且不等於 Infinite (-1 毫秒),或大於 MaxValueThe value of timeout in milliseconds is negative and is not equal to Infinite (-1 millisecond), or is greater than MaxValue.

備註

如果值timeout轉換為毫秒的參數等於-1,這個方法就相當於Enter(Object)If the value of the timeout parameter converted to milliseconds equals -1, this method is equivalent to Enter(Object). 如果值timeout等於 0,此方法相當於TryEnter(Object)If the value of timeout equals 0, this method is equivalent to TryEnter(Object).

如果無法取得鎖定,因為發生例外狀況,針對指定的變數lockTaken參數是false這個方法會結束之後。If the lock was not taken because an exception was thrown, the variable specified for the lockTaken parameter is false after this method ends. 這可讓程式,以判斷是否需要釋出鎖定,請在所有情況下。This allows the program to determine, in all cases, whether it is necessary to release the lock.

注意

使用Monitor鎖定物件 (也就是參考類型),不實值型別。Use Monitor to lock objects (that is, reference types), not value types. 如需詳細資訊,請參閱Monitor類別主題。For more information, see the Monitor class topic.

為了確保執行緒不會進入重要區段,您應該檢查的值lockTaken並執行程式碼在重要區段中,只有其值是trueTo ensure that the thread does not enter the critical section, you should examine the value of lockTaken and execute code in the critical section only if its value is true. 下列程式碼片段會顯示用來呼叫這個方法的模式。The following code fragment shows the pattern used to call this method. 請注意,您應該呼叫Exitfinally區塊以確保呼叫執行緒釋放重要區段上的鎖定,如果發生例外狀況。Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
var timeout = TimeSpan.FromMilliseconds(500);
bool lockTaken = false;

try {
   Monitor.TryEnter(lockObj, timeout, ref lockTaken);
   if (lockTaken) {
      // The critical section.
   }
   else {
      // The lock was not acquired.
   }
}
finally {
   // Ensure that the lock is released.
   if (lockTaken) {
      Monitor.Exit(lockObj);
   }
}
Dim lockObj As New Object()
Dim timeout = TimeSpan.FromMilliseconds(500)
Dim lockTaken As Boolean = False

Try
   Monitor.TryEnter(lockObj, timeout, lockTaken)
   If lockTaken Then
      ' The critical section.
   Else
      ' The lock was not acquired.
   End If
Finally
   ' Ensure that the lock is released.
   If lockTaken Then Monitor.Exit(lockObj)
End Try
另請參閱

TryEnter(Object, Int32, Boolean) TryEnter(Object, Int32, Boolean) TryEnter(Object, Int32, Boolean) TryEnter(Object, Int32, Boolean)

嘗試在指定的毫秒數內取得指定之物件的獨佔鎖定,並且完整設定值,指出是否採用鎖定。Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken.

public:
 static void TryEnter(System::Object ^ obj, int millisecondsTimeout, bool % lockTaken);
public static void TryEnter (object obj, int millisecondsTimeout, ref bool lockTaken);
static member TryEnter : obj * int *  -> unit
Public Shared Sub TryEnter (obj As Object, millisecondsTimeout As Integer, ByRef lockTaken As Boolean)

參數

obj
Object Object Object Object

要取得鎖定的物件。The object on which to acquire the lock.

millisecondsTimeout
Int32 Int32 Int32 Int32

等候鎖定的毫秒數。The number of milliseconds to wait for the lock.

lockTaken
Boolean Boolean Boolean Boolean

嘗試取得鎖定的結果 (以傳址方式傳遞)。The result of the attempt to acquire the lock, passed by reference. 輸入必須是 falseThe input must be false. 如果已取得鎖定,輸出就是 true;否則輸出為 falseThe output is true if the lock is acquired; otherwise, the output is false. 嘗試取得鎖定期間,即使發生例外狀況,仍然會設定輸出。The output is set even if an exception occurs during the attempt to acquire the lock.

例外狀況

lockTaken 的輸入為 trueThe input to lockTaken is true.

millisecondsTimeout 是負數,且不等於 InfinitemillisecondsTimeout is negative, and not equal to Infinite.

範例

下列程式碼示範基本模式使用TryEnter(Object, Boolean)方法多載。The following code shows the basic pattern for using the TryEnter(Object, Boolean) method overload. 這個多載一定會設定傳遞至變數的值ref參數 (ByRef Visual Basic 中) lockTaken,即使方法會擲回例外狀況,因此變數的值是以可靠的方式,來測試是否鎖定必須為釋出。This overload always sets the value of the variable that is passed to the ref parameter (ByRef in Visual Basic) lockTaken, even if the method throws an exception, so the value of the variable is a reliable way to test whether the lock has to be released.

bool acquiredLock = false;

try
{
    Monitor.TryEnter(lockObject, 500, ref acquiredLock);
    if (acquiredLock)
    {

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

    }
    else
    {
    
        // Code to deal with the fact that the lock was not acquired.

    }
}
finally
{
    if (acquiredLock)
    {
        Monitor.Exit(lockObject);
    }
}
Dim acquiredLock As Boolean = False

Try
    Monitor.TryEnter(lockObject, 500, acquiredLock)
    If acquiredLock Then

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

    Else

        ' Code to deal with the fact that the lock was not acquired.

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

備註

如果millisecondsTimeout參數等於Infinite,這個方法相當於Enter(Object)If the millisecondsTimeout parameter equals Infinite, this method is equivalent to Enter(Object). 如果millisecondsTimeout等於 0,此方法相當於TryEnter(Object)If millisecondsTimeout equals 0, this method is equivalent to TryEnter(Object).

如果無法取得鎖定,因為發生例外狀況,針對指定的變數lockTaken參數是false這個方法會結束之後。If the lock was not taken because an exception was thrown, the variable specified for the lockTaken parameter is false after this method ends. 這可讓程式,以判斷是否需要釋出鎖定,請在所有情況下。This allows the program to determine, in all cases, whether it is necessary to release the lock.

注意

使用Monitor鎖定物件 (也就是參考類型),不實值型別。Use Monitor to lock objects (that is, reference types), not value types. 如需詳細資訊,請參閱Monitor類別主題。For more information, see the Monitor class topic.

為了確保執行緒不會進入重要區段,您應該檢查的值lockTaken並執行程式碼在重要區段中,只有其值是trueTo ensure that the thread does not enter the critical section, you should examine the value of lockTaken and execute code in the critical section only if its value is true. 下列程式碼片段會顯示用來呼叫這個方法的模式。The following code fragment shows the pattern used to call this method. 請注意,您應該呼叫Exitfinally區塊以確保呼叫執行緒釋放重要區段上的鎖定,如果發生例外狀況。Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
int timeout = 500;
bool lockTaken = false;

try {
   Monitor.TryEnter(lockObj, timeout, ref lockTaken);
   if (lockTaken) {
      // The critical section.
   }
   else {
      // The lock was not acquired.
   }
}
finally {
   // Ensure that the lock is released.
   if (lockTaken) {
      Monitor.Exit(lockObj);
   }   
}
Dim lockObj As New Object()
Dim timeout As Integer = 500
Dim lockTaken As Boolean = False

Try
   Monitor.TryEnter(lockObj, timeout, lockTaken)
   If lockTaken Then
      ' The critical section.
   Else
      ' The lock was not acquired.
   End If
Finally
   ' Ensure that the lock is released.
   If lockTaken Then Monitor.Exit(lockObj)
End Try

TryEnter(Object, TimeSpan) TryEnter(Object, TimeSpan) TryEnter(Object, TimeSpan) TryEnter(Object, TimeSpan)

嘗試取得指定物件的獨佔鎖定 (在指定的時間內)。Attempts, for the specified amount of time, to acquire an exclusive lock on the specified object.

public:
 static bool TryEnter(System::Object ^ obj, TimeSpan timeout);
public static bool TryEnter (object obj, TimeSpan timeout);
static member TryEnter : obj * TimeSpan -> bool
Public Shared Function TryEnter (obj As Object, timeout As TimeSpan) As Boolean

參數

obj
Object Object Object Object

要取得鎖定的物件。The object on which to acquire the lock.

timeout
TimeSpan TimeSpan TimeSpan TimeSpan

TimeSpan,代表等候鎖定的時間量。A TimeSpan representing the amount of time to wait for the lock. -1 毫秒的值會指定無限期等候。A value of -1 millisecond specifies an infinite wait.

傳回

如果目前執行緒取得鎖定,則為 true;否則為 falsetrue if the current thread acquires the lock; otherwise, false.

例外狀況

timeout 的毫秒值為負值且不等於 Infinite (-1 毫秒),或大於 MaxValueThe value of timeout in milliseconds is negative and is not equal to Infinite (-1 millisecond), or is greater than MaxValue.

備註

如果值timeout轉換為毫秒的參數等於-1,這個方法就相當於EnterIf the value of the timeout parameter converted to milliseconds equals -1, this method is equivalent to Enter. 如果值timeout等於 0,此方法相當於TryEnterIf the value of timeout equals 0, this method is equivalent to TryEnter.

注意

使用Monitor鎖定物件 (也就是參考類型),不實值型別。Use Monitor to lock objects (that is, reference types), not value types. 如需詳細資訊,請參閱Monitor類別主題。For details, see the Monitor class topic.

若要確保執行緒不會進入重要區段,您應該檢查方法的傳回值,並在重要區段中執行程式碼,其傳回值時,才trueTo ensure that the thread does not enter the critical section, you should examine the method's return value and execute code in the critical section only if its return value is true. 下列程式碼片段會顯示用來呼叫這個方法的模式。The following code fragment shows the pattern used to call this method. 請注意,您應該呼叫Exitfinally區塊以確保呼叫執行緒釋放重要區段上的鎖定,如果發生例外狀況。Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
var timeout = TimeSpan.FromMilliseconds(500);

if (Monitor.TryEnter(lockObj, timeout)) {
   try {
      // The critical section.
   }
   finally {
      // Ensure that the lock is released.
      Monitor.Exit(lockObj);
   }
}
else {
   // The lock was not acquired.
}
Dim lockObj As New Object()
Dim timeout = TimeSpan.FromMilliseconds(500)

If Monitor.TryEnter(lockObj, timeout) Then
   Try
      ' The critical section.
   Finally
      ' Ensure that the lock is released.
      Monitor.Exit(lockObj)
   End Try
Else
   ' The lock was not acquired.
End If
另請參閱

TryEnter(Object, Boolean) TryEnter(Object, Boolean) TryEnter(Object, Boolean) TryEnter(Object, Boolean)

嘗試取得指定之物件的獨佔鎖定,並且完整設定值,指出是否採用鎖定。Attempts to acquire an exclusive lock on the specified object, and atomically sets a value that indicates whether the lock was taken.

public:
 static void TryEnter(System::Object ^ obj, bool % lockTaken);
public static void TryEnter (object obj, ref bool lockTaken);
static member TryEnter : obj *  -> unit
Public Shared Sub TryEnter (obj As Object, ByRef lockTaken As Boolean)

參數

obj
Object Object Object Object

要取得鎖定的物件。The object on which to acquire the lock.

lockTaken
Boolean Boolean Boolean Boolean

嘗試取得鎖定的結果 (以傳址方式傳遞)。The result of the attempt to acquire the lock, passed by reference. 輸入必須是 falseThe input must be false. 如果已取得鎖定,輸出就是 true;否則輸出為 falseThe output is true if the lock is acquired; otherwise, the output is false. 嘗試取得鎖定期間,即使發生例外狀況,仍然會設定輸出。The output is set even if an exception occurs during the attempt to acquire the lock.

例外狀況

lockTaken 的輸入為 trueThe input to lockTaken is true.

範例

下列程式碼示範基本模式使用TryEnter(Object, Boolean)方法多載。The following code shows the basic pattern for using the TryEnter(Object, Boolean) method overload. 這個多載一定會設定傳遞至變數的值ref參數 (ByRef Visual Basic 中) lockTaken,即使方法會擲回例外狀況,因此變數的值是以可靠的方式,來測試是否鎖定必須為釋出。This overload always sets the value of the variable that is passed to the ref parameter (ByRef in Visual Basic) lockTaken, even if the method throws an exception, so the value of the variable is a reliable way to test whether the lock has to be released.

bool acquiredLock = false;

try
{
    Monitor.TryEnter(lockObject, ref acquiredLock);
    if (acquiredLock)
    {

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

    }
    else
    {
    
        // Code to deal with the fact that the lock was not acquired.

    }
}
finally
{
    if (acquiredLock)
    {
        Monitor.Exit(lockObject);
    }
}
Dim acquiredLock As Boolean = False

Try
    Monitor.TryEnter(lockObject, acquiredLock)
    If acquiredLock Then

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

    Else

        ' Code to deal with the fact that the lock was not acquired.

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

備註

如果成功,這個方法會取得獨佔的鎖定上obj參數。If successful, this method acquires an exclusive lock on the obj parameter. 這個方法會立即傳回,鎖定可用。This method returns immediately, whether or not the lock is available.

如果無法取得鎖定,因為發生例外狀況,針對指定的變數lockTaken參數是false這個方法會結束之後。If the lock was not taken because an exception was thrown, the variable specified for the lockTaken parameter is false after this method ends. 這可讓程式,以判斷是否需要釋出鎖定,請在所有情況下。This allows the program to determine, in all cases, whether it is necessary to release the lock.

這個方法很類似Enter(Object, Boolean),但它會永遠不會封鎖目前的執行緒。This method is similar to Enter(Object, Boolean), but it will never block the current thread. 如果執行緒無法輸入而不會封鎖,lockTaken引數設定為false方法傳回時。If the thread cannot enter without blocking, the lockTaken argument is set to false when the method returns.

注意

使用Monitor鎖定物件 (也就是參考類型),不實值型別。Use Monitor to lock objects (that is, reference types), not value types. 如需詳細資訊,請參閱Monitor文章。For more information, see the Monitor article.

為了確保執行緒不會進入重要區段,您應該檢查的值lockTaken並執行程式碼在重要區段中,只有其值是trueTo ensure that the thread does not enter the critical section, you should examine the value of lockTaken and execute code in the critical section only if its value is true. 下列程式碼片段會顯示用來呼叫這個方法的模式。The following code fragment shows the pattern used to call this method. 請注意,您應該呼叫Exitfinally區塊以確保呼叫執行緒釋放重要區段上的鎖定,如果發生例外狀況。Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
bool lockTaken = false;

try {
   Monitor.TryEnter(lockObj, ref lockTaken); 
   if (lockTaken) {
      // The critical section.
   }
   else {
      // The lock was not acquired.
   }
}
finally {
   // Ensure that the lock is released.
   if (lockTaken) {
      Monitor.Exit(lockObj);
   }
}
Dim lockObj As New Object()
Dim lockTaken As Boolean = False

Try 
   Monitor.TryEnter(lockObj, lockTaken) 
   If lockTaken Then
      ' The critical section.
   Else 
      ' The lock was not acquired.
   End If
Finally 
   ' Ensure that the lock is released.
   If lockTaken Then Monitor.Exit(lockObj)
End Try

TryEnter(Object) TryEnter(Object) TryEnter(Object) TryEnter(Object)

嘗試取得指定物件的獨佔鎖定。Attempts to acquire an exclusive lock on the specified object.

public:
 static bool TryEnter(System::Object ^ obj);
public static bool TryEnter (object obj);
static member TryEnter : obj -> bool
Public Shared Function TryEnter (obj As Object) As Boolean

參數

obj
Object Object Object Object

要取得鎖定的物件。The object on which to acquire the lock.

傳回

如果目前執行緒取得鎖定,則為 true;否則為 falsetrue if the current thread acquires the lock; otherwise, false.

例外狀況

範例

下列程式碼範例會示範如何使用 TryEnter 方法。The following code example demonstrates how to use the TryEnter method.

#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

備註

如果成功,這個方法會取得獨佔的鎖定上obj參數。If successful, this method acquires an exclusive lock on the obj parameter. 這個方法會立即傳回,鎖定可用。This method returns immediately, whether or not the lock is available.

這個方法很類似Enter,但它會永遠不會封鎖目前的執行緒。This method is similar to Enter, but it will never block the current thread. 如果執行緒無法輸入而不會封鎖,則方法會傳回false,If the thread cannot enter without blocking, the method returns false,.

注意

使用Monitor鎖定物件 (也就是參考類型),不實值型別。Use Monitor to lock objects (that is, reference types), not value types. 如需詳細資訊,請參閱Monitor文章。For details, see the Monitor article.

若要確保執行緒不會進入重要區段,您應該檢查方法的傳回值,並在重要區段中執行程式碼,其傳回值時,才trueTo ensure that the thread does not enter the critical section, you should examine the method's return value and execute code in the critical section only if its return value is true. 下列程式碼片段會顯示用來呼叫這個方法的模式。The following code fragment shows the pattern used to call this method. 請注意,您應該呼叫Exitfinally區塊以確保呼叫執行緒釋放重要區段上的鎖定,如果發生例外狀況。Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();

if (Monitor.TryEnter(lockObj)) {
   try {
      // The critical section.
   }
   finally {
      // Ensure that the lock is released.
      Monitor.Exit(lockObj);
   }
}
else {
   // The lock was not axquired.
}
Dim lockObj As New Object()

If Monitor.TryEnter(lockObj) Then
   Try
      ' The critical section.
   Finally
      ' Ensure that the lock is released.
      Monitor.Exit(lockObj)
   End Try
Else
   ' The lock was not acquired.
End If
另請參閱

TryEnter(Object, Int32) TryEnter(Object, Int32) TryEnter(Object, Int32) TryEnter(Object, Int32)

嘗試取得指定物件的獨佔鎖定 (在指定的毫秒數時間內)。Attempts, for the specified number of milliseconds, to acquire an exclusive lock on the specified object.

public:
 static bool TryEnter(System::Object ^ obj, int millisecondsTimeout);
public static bool TryEnter (object obj, int millisecondsTimeout);
static member TryEnter : obj * int -> bool
Public Shared Function TryEnter (obj As Object, millisecondsTimeout As Integer) As Boolean

參數

obj
Object Object Object Object

要取得鎖定的物件。The object on which to acquire the lock.

millisecondsTimeout
Int32 Int32 Int32 Int32

等候鎖定的毫秒數。The number of milliseconds to wait for the lock.

傳回

如果目前執行緒取得鎖定,則為 true;否則為 falsetrue if the current thread acquires the lock; otherwise, false.

例外狀況

millisecondsTimeout 是負數,且不等於 InfinitemillisecondsTimeout is negative, and not equal to Infinite.

備註

如果millisecondsTimeout參數等於Infinite,這個方法相當於EnterIf the millisecondsTimeout parameter equals Infinite, this method is equivalent to Enter. 如果millisecondsTimeout等於 0,此方法相當於TryEnterIf millisecondsTimeout equals 0, this method is equivalent to TryEnter.

注意

使用Monitor鎖定物件 (也就是參考類型),不實值型別。Use Monitor to lock objects (that is, reference types), not value types. 如需詳細資訊,請參閱Monitor文章。For details, see the Monitor article.

若要確保執行緒不會進入重要區段,您應該檢查方法的傳回值,並在重要區段中執行程式碼,其傳回值時,才trueTo ensure that the thread does not enter the critical section, you should examine the method's return value and execute code in the critical section only if its return value is true. 下列程式碼片段會顯示用來呼叫這個方法的模式。The following code fragment shows the pattern used to call this method. 請注意,您應該呼叫Exitfinally區塊以確保呼叫執行緒釋放重要區段上的鎖定,如果發生例外狀況。Note that you should call Exit in a finally block to ensure that the calling thread releases its lock on the critical section if an exception occurs.

var lockObj = new Object();
int timeout = 500;

if (Monitor.TryEnter(lockObj, timeout)) {
   try {
      // The critical section.
   }
   finally {
      // Ensure that the lock is released.
      Monitor.Exit(lockObj);
   }
}
else {
   // The lock was not acquired.
}
Dim lockObj As New Object()
Dim timeout As Integer = 500

If Monitor.TryEnter(lockObj, timeout) Then
   Try
      ' The critical section.
   Finally
      ' Ensure that the lock is released.
      Monitor.Exit(lockObj)
   End Try
Else
   ' The lock was not acquired.
End If
另請參閱

適用於