Monitor.TryEnter Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten.
Überlädt
| TryEnter(Object, TimeSpan, Boolean) |
Versucht für die angegebene Dauer, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. |
| TryEnter(Object, Int32, Boolean) |
Versucht für die angegebene Anzahl von Millisekunden, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. |
| TryEnter(Object, TimeSpan) |
Versucht über einen angegebenen Zeitraum hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. |
| TryEnter(Object, Boolean) |
Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde. |
| TryEnter(Object) |
Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten. |
| TryEnter(Object, Int32) |
Versucht über eine angegebene Anzahl von Millisekunden hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten. |
TryEnter(Object, TimeSpan, Boolean)
- Quelle:
- Monitor.cs
- Quelle:
- Monitor.cs
- Quelle:
- Monitor.cs
Versucht für die angegebene Dauer, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde.
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 * bool -> unitPublic Shared Sub TryEnter (obj As Object, timeout As TimeSpan, ByRef lockTaken As Boolean)Parameter
- obj
- Object
Das Objekt, für das die Sperre erhalten werden soll.
- timeout
- TimeSpan
Die Zeitspanne, für die auf die Sperre gewartet werden soll. Ein Wert von –1 Millisekunde gibt eine unbegrenzte Wartezeit an.
- lockTaken
- Boolean
Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis. Die Eingabe muss false sein. Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false. Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen.
Ausnahmen
Die Eingabe für lockTaken ist true.
Der obj-Parameter ist null.
Der Wert von timeout in Millisekunden ist negativ und ist nicht gleich Infinite (-1 Millisekunde) oder größer als Int32.MaxValue.
Hinweise
Wenn der Wert des timeout in Millisekunden konvertierten Parameters gleich -1 ist, entspricht Enter(Object)diese Methode . Wenn der Wert von timeout gleich 0 ist, entspricht diese Methode .TryEnter(Object)
Wenn die Sperre nicht ausgeführt wurde, weil eine Ausnahme ausgelöst wurde, befindet false sich die für den lockTaken Parameter angegebene Variable nach dem Ende dieser Methode. Dadurch kann das Programm in allen Fällen feststellen, ob es notwendig ist, die Sperre zu lösen.
Hinweis
Verwenden Sie Monitor zum Sperren von Objekten (d. h. Verweistypen), nicht zum Sperren von Werttypen. Weitere Informationen finden Sie im Monitor Klassenthema.
Um sicherzustellen, dass der Thread nicht in den kritischen Abschnitt eintritt, sollten Sie den Wert von lockTaken untersuchen und Code im kritischen Abschnitt nur dann ausführen, wenn sein Wert ist true. Das folgende Codefragment zeigt das Muster, mit dem diese Methode aufgerufen wird. Beachten Sie, dass Sie einen finally Block aufrufen Exit sollten, um sicherzustellen, dass der aufrufende Thread seine Sperre für den kritischen Abschnitt freigibt, wenn eine Ausnahme auftritt.
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
Weitere Informationen
Gilt für:
TryEnter(Object, Int32, Boolean)
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
Versucht für die angegebene Anzahl von Millisekunden, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde.
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 * bool -> unitPublic Shared Sub TryEnter (obj As Object, millisecondsTimeout As Integer, ByRef lockTaken As Boolean)Parameter
- obj
- Object
Das Objekt, für das die Sperre erhalten werden soll.
- millisecondsTimeout
- Int32
Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll.
- lockTaken
- Boolean
Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis. Die Eingabe muss false sein. Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false. Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen.
Ausnahmen
Die Eingabe für lockTaken ist true.
Der obj-Parameter ist null.
millisecondsTimeout ist negativ und ungleich Infinite.
Beispiele
Der folgende Code zeigt das grundlegende Muster für die Verwendung der TryEnter(Object, Boolean) Methodenüberladung. Diese Überladung legt immer den Wert der Variablen fest, die an den ref Parameter (ByRef in Visual Basic) lockTakenübergeben wird, auch wenn die Methode eine Ausnahme auslöst, sodass der Wert der Variablen eine zuverlässige Möglichkeit ist, zu testen, ob die Sperre freigegeben werden muss.
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
Hinweise
Wenn der millisecondsTimeout Parameter gleich Infiniteist, entspricht diese Methode .Enter(Object) Wenn millisecondsTimeout gleich 0 ist, entspricht diese Methode .TryEnter(Object)
Wenn die Sperre nicht ausgeführt wurde, weil eine Ausnahme ausgelöst wurde, befindet false sich die für den lockTaken Parameter angegebene Variable nach dem Ende dieser Methode. Dadurch kann das Programm in allen Fällen feststellen, ob es notwendig ist, die Sperre zu lösen.
Hinweis
Verwenden Sie Monitor zum Sperren von Objekten (d. h. Verweistypen), nicht zum Sperren von Werttypen. Weitere Informationen finden Sie im Monitor Klassenthema.
Um sicherzustellen, dass der Thread nicht in den kritischen Abschnitt eintritt, sollten Sie den Wert von lockTaken untersuchen und Code im kritischen Abschnitt nur dann ausführen, wenn sein Wert ist true. Das folgende Codefragment zeigt das Muster, mit dem diese Methode aufgerufen wird. Beachten Sie, dass Sie einen finally Block aufrufen Exit sollten, um sicherzustellen, dass der aufrufende Thread seine Sperre für den kritischen Abschnitt freigibt, wenn eine Ausnahme auftritt.
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
Gilt für:
TryEnter(Object, TimeSpan)
- Quelle:
- Monitor.cs
- Quelle:
- Monitor.cs
- Quelle:
- Monitor.cs
Versucht über einen angegebenen Zeitraum hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten.
public:
static bool TryEnter(System::Object ^ obj, TimeSpan timeout);public static bool TryEnter (object obj, TimeSpan timeout);static member TryEnter : obj * TimeSpan -> boolPublic Shared Function TryEnter (obj As Object, timeout As TimeSpan) As BooleanParameter
- obj
- Object
Das Objekt, für das die Sperre erhalten werden soll.
- timeout
- TimeSpan
Eine TimeSpan, die die Zeitspanne darstellt, für die auf die Sperre gewartet werden soll. Ein Wert von –1 Millisekunde gibt eine unbegrenzte Wartezeit an.
Gibt zurück
true, wenn der aktuelle Thread die Sperre erhält, andernfalls false.
Ausnahmen
Der obj-Parameter ist null.
Der Wert von timeout in Millisekunden ist negativ und ist nicht gleich Infinite (-1 Millisekunde) oder größer als Int32.MaxValue.
Hinweise
Wenn der Wert des timeout in Millisekunden konvertierten Parameters gleich -1 ist, entspricht Enterdiese Methode . Wenn der Wert von timeout gleich 0 ist, entspricht diese Methode .TryEnter
Hinweis
Verwenden Sie Monitor zum Sperren von Objekten (d. h. Verweistypen), nicht zum Sperren von Werttypen. Ausführliche Informationen finden Sie im Monitor Klassenthema.
Um sicherzustellen, dass der Thread nicht in den kritischen Abschnitt eintritt, sollten Sie den Rückgabewert der Methode untersuchen und Code im kritischen Abschnitt nur ausführen, wenn ihr Rückgabewert ist true. Das folgende Codefragment zeigt das Muster, mit dem diese Methode aufgerufen wird. Beachten Sie, dass Sie einen finally Block aufrufen Exit sollten, um sicherzustellen, dass der aufrufende Thread seine Sperre für den kritischen Abschnitt freigibt, wenn eine Ausnahme auftritt.
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
Weitere Informationen
Gilt für:
TryEnter(Object, Boolean)
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten, und legt atomar einen Wert fest, der angibt, ob die Sperre angenommen wurde.
public:
static void TryEnter(System::Object ^ obj, bool % lockTaken);public static void TryEnter (object obj, ref bool lockTaken);static member TryEnter : obj * bool -> unitPublic Shared Sub TryEnter (obj As Object, ByRef lockTaken As Boolean)Parameter
- obj
- Object
Das Objekt, für das die Sperre erhalten werden soll.
- lockTaken
- Boolean
Das Ergebnis des Versuchs, die Sperre abzurufen, übergeben als Verweis. Die Eingabe muss false sein. Die Ausgabe ist true, wenn die Sperre abgerufen wurde. Andernfalls ist die Ausgabe false. Die Ausgabe wird auch dann festgelegt, wenn eine Ausnahme bei dem Versuch auftritt, die Sperre abzurufen.
Ausnahmen
Die Eingabe für lockTaken ist true.
Der obj-Parameter ist null.
Beispiele
Der folgende Code zeigt das grundlegende Muster für die Verwendung der TryEnter(Object, Boolean) Methodenüberladung. Diese Überladung legt immer den Wert der Variablen fest, die an den ref Parameter (ByRef in Visual Basic) lockTakenübergeben wird, auch wenn die Methode eine Ausnahme auslöst, sodass der Wert der Variablen eine zuverlässige Möglichkeit ist, zu testen, ob die Sperre freigegeben werden muss.
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
Hinweise
Bei erfolgreicher Ausführung erhält diese Methode eine exklusive Sperre für den obj Parameter. Diese Methode gibt sofort zurück, unabhängig davon, ob die Sperre verfügbar ist oder nicht.
Wenn die Sperre nicht ausgeführt wurde, weil eine Ausnahme ausgelöst wurde, befindet false sich die für den lockTaken Parameter angegebene Variable nach dem Ende dieser Methode. Dadurch kann das Programm in allen Fällen feststellen, ob es notwendig ist, die Sperre zu lösen.
Diese Methode ähnelt Enter(Object, Boolean), wird aber nie den aktuellen Thread blockieren. Wenn der Thread nicht ohne Blockieren eingeben kann, wird das lockTaken Argument auf false festgelegt, wenn die Methode zurückgibt.
Hinweis
Verwenden Sie Monitor zum Sperren von Objekten (d. h. Verweistypen), nicht zum Sperren von Werttypen. Weitere Informationen finden Sie im Artikel Monitor.
Um sicherzustellen, dass der Thread nicht in den kritischen Abschnitt eintritt, sollten Sie den Wert von lockTaken untersuchen und Code im kritischen Abschnitt nur dann ausführen, wenn sein Wert ist true. Das folgende Codefragment zeigt das Muster, mit dem diese Methode aufgerufen wird. Beachten Sie, dass Sie einen finally Block aufrufen Exit sollten, um sicherzustellen, dass der aufrufende Thread seine Sperre für den kritischen Abschnitt freigibt, wenn eine Ausnahme auftritt.
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
Gilt für:
TryEnter(Object)
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
Versucht, eine exklusive Sperre für das angegebene Objekt zu erhalten.
public:
static bool TryEnter(System::Object ^ obj);public static bool TryEnter (object obj);static member TryEnter : obj -> boolPublic Shared Function TryEnter (obj As Object) As BooleanParameter
- obj
- Object
Das Objekt, für das die Sperre erhalten werden soll.
Gibt zurück
true, wenn der aktuelle Thread die Sperre erhält, andernfalls false.
Ausnahmen
Der obj-Parameter ist null.
Beispiele
Das folgende Codebeispiel zeigt, wie Sie die TryEnter-Methode verwenden.
#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
Hinweise
Bei erfolgreicher Ausführung erhält diese Methode eine exklusive Sperre für den obj Parameter. Diese Methode gibt sofort zurück, unabhängig davon, ob die Sperre verfügbar ist.
Diese Methode ähnelt Enter, wird aber niemals den aktuellen Thread blockieren. Wenn der Thread nicht ohne Blockieren eintreten kann, gibt die -Methode zurück false,.
Hinweis
Verwenden Sie Monitor zum Sperren von Objekten (d. h. Verweistypen), nicht zum Sperren von Werttypen. Ausführliche Informationen finden Sie im Monitor Artikel.
Um sicherzustellen, dass der Thread nicht in den kritischen Abschnitt wechselt, sollten Sie den Rückgabewert der Methode untersuchen und code im kritischen Abschnitt nur ausführen, wenn der Rückgabewert ist true. Das folgende Codefragment zeigt das Muster, das zum Aufrufen dieser Methode verwendet wird. Beachten Sie, dass Sie in einem finally -Block aufrufen Exit sollten, um sicherzustellen, dass der aufrufende Thread seine Sperre für den kritischen Abschnitt freigibt, wenn eine Ausnahme auftritt.
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
Weitere Informationen
Gilt für:
TryEnter(Object, Int32)
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
- Quelle:
- Monitor.CoreCLR.cs
Versucht über eine angegebene Anzahl von Millisekunden hinweg, eine exklusive Sperre für das angegebene Objekt zu erhalten.
public:
static bool TryEnter(System::Object ^ obj, int millisecondsTimeout);public static bool TryEnter (object obj, int millisecondsTimeout);static member TryEnter : obj * int -> boolPublic Shared Function TryEnter (obj As Object, millisecondsTimeout As Integer) As BooleanParameter
- obj
- Object
Das Objekt, für das die Sperre erhalten werden soll.
- millisecondsTimeout
- Int32
Die Anzahl der Millisekunden, für die auf die Sperre gewartet werden soll.
Gibt zurück
true, wenn der aktuelle Thread die Sperre erhält, andernfalls false.
Ausnahmen
Der obj-Parameter ist null.
millisecondsTimeout ist negativ und ungleich Infinite.
Hinweise
Wenn der millisecondsTimeout Parameter gleich Infiniteist, entspricht Enterdiese Methode . Wenn millisecondsTimeout gleich 0 ist, entspricht TryEnterdiese Methode .
Hinweis
Verwenden Sie Monitor zum Sperren von Objekten (d. h. Verweistypen), nicht zum Sperren von Werttypen. Ausführliche Informationen finden Sie im Monitor Artikel.
Um sicherzustellen, dass der Thread nicht in den kritischen Abschnitt wechselt, sollten Sie den Rückgabewert der Methode untersuchen und code im kritischen Abschnitt nur ausführen, wenn der Rückgabewert ist true. Das folgende Codefragment zeigt das Muster, das zum Aufrufen dieser Methode verwendet wird. Beachten Sie, dass Sie in einem finally -Block aufrufen Exit sollten, um sicherzustellen, dass der aufrufende Thread seine Sperre für den kritischen Abschnitt freigibt, wenn eine Ausnahme auftritt.
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
