Interlocked-Klasse
Stellt atomare Operationen für Variablen bereit, die von mehreren Threads gemeinsam genutzt werden.
Namespace: System.Threading
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
Public NotInheritable Class Interlocked
'Usage
Auf die Member einer statischen Klassen wird direkt ohne Instanz der Klasse zugegriffen.
public static class Interlocked
public ref class Interlocked abstract sealed
public final class Interlocked
public final class Interlocked
Hinweise
Die Methoden dieser Klasse schützen vor Fehlern, die auftreten können, wenn der Planer zwischen Kontexten wechselt, während ein Thread eine Variable aktualisiert, auf die mehrere andere Threads zugreifen können, oder wenn zwei Threads gleichzeitig von unterschiedlichen Prozessoren ausgeführt werden. Die Member dieser Klasse lösen keine Ausnahmen aus.
Die Increment-Methode und die Decrement-Methode erhöhen bzw. verringern den Wert einer Variablen und speichern den erhaltenen Wert in einer einzigen Operation. Bei den meisten Computern ist das Inkrementieren einer Variablen kein atomarer Vorgang und erfordert die folgenden Schritte:
Laden eines Werts aus einer Instanzvariablen in ein Register.
Erhöhen oder Vermindern des Werts.
Speichern des Werts in der Instanzvariablen.
Wenn Sie nicht Increment und Decrement verwenden, kann ein Thread nach dem Ausführen der ersten beiden Schritte präemptiv verdrängt werden. Ein anderer Thread kann dann alle drei Schritte ausführen. Wenn der erste Thread mit der Ausführung fortfährt, überschreibt er den Wert in der Instanzvariablen, und das Erhöhen bzw. Vermindern durch den zweiten Thread hat keine Wirkung.
Die Exchange-Methode tauscht die Werte der angegebenen Variablen atomar aus. Die CompareExchange-Methode kombiniert zwei Operationen: Es werden zwei Werte miteinander verglichen, und in einer der Variablen wird auf der Grundlage des Vergleichsergebnisses ein dritter Wert gespeichert. Die Vergleichs- und die Austauschoperation werden als atomare Operation ausgeführt.
Beispiel
Das folgende Codebeispiel veranschaulicht einen threadsicheren Mechanismus zum Sperren von Ressourcen.
Imports System
Imports System.Threading
Namespace InterlockedExchange_Example
Class MyInterlockedExchangeExampleClass
'0 for false, 1 for true.
Private Shared usingResource As Integer = 0
Private Shared currentMso As [Object]
Private Shared globalMso As New [Object]()
Private Const numThreadIterations As Integer = 5
Private Const numThreads As Integer = 10
<MTAThread> _
Shared Sub Main()
Dim myThread As Thread
Dim rnd As New Random()
Dim i As Integer
For i = 0 To numThreads - 1
myThread = New Thread(AddressOf MyThreadProc)
myThread.Name = [String].Format("Thread{0}", i + 1)
'Wait a random amount of time before starting next thread.
Thread.Sleep(rnd.Next(0, 1000))
myThread.Start()
Next i
End Sub 'Main
Private Shared Sub MyThreadProc()
Dim i As Integer
For i = 0 To numThreadIterations - 1
UseResource()
'Wait 1 second before next attempt.
Thread.Sleep(1000)
Next i
End Sub 'MyThreadProc
'A simple method that denies reentrancy.
Shared Function UseResource() As Boolean
'0 indicates that the method is not in use.
If 0 = Interlocked.Exchange(usingResource, 1) Then
Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name)
'Code to access a resource that is not thread safe would go here.
'Simulate some work
Thread.Sleep(500)
Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name)
'Release the lock
Interlocked.Exchange(usingResource, 0)
Return True
Else
Console.WriteLine(" {0} was denied the lock", Thread.CurrentThread.Name)
Return False
End If
End Function 'UseResource
End Class 'MyInterlockedExchangeExampleClass
End Namespace 'InterlockedExchange_Example
using System;
using System.Threading;
namespace InterlockedExchange_Example
{
class MyInterlockedExchangeExampleClass
{
//0 for false, 1 for true.
private static int usingResource = 0;
private static Object currentMso;
private static Object globalMso = new Object();
private const int numThreadIterations = 5;
private const int numThreads = 10;
static void Main()
{
Thread myThread;
Random rnd = new Random();
for(int i = 0; i < numThreads; i++)
{
myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.Name = String.Format("Thread{0}", i + 1);
//Wait a random amount of time before starting next thread.
Thread.Sleep(rnd.Next(0, 1000));
myThread.Start();
}
}
private static void MyThreadProc()
{
for(int i = 0; i < numThreadIterations; i++)
{
UseResource();
//Wait 1 second before next attempt.
Thread.Sleep(1000);
}
}
//A simple method that denies reentrancy.
static bool UseResource()
{
//0 indicates that the method is not in use.
if(0 == Interlocked.Exchange(ref usingResource, 1))
{
Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
//Code to access a resource that is not thread safe would go here.
//Simulate some work
Thread.Sleep(500);
Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
//Release the lock
Interlocked.Exchange(ref usingResource, 0);
return true;
}
else
{
Console.WriteLine(" {0} was denied the lock", Thread.CurrentThread.Name);
return false;
}
}
}
}
using namespace System;
using namespace System::Threading;
const int numThreads = 10;
const int numThreadIterations = 5;
ref class MyInterlockedExchangeExampleClass
{
public:
static void MyThreadProc()
{
for ( int i = 0; i < numThreadIterations; i++ )
{
UseResource();
//Wait 1 second before next attempt.
Thread::Sleep( 1000 );
}
}
private:
//A simple method that denies reentrancy.
static bool UseResource()
{
//0 indicates that the method is not in use.
if ( 0 == Interlocked::Exchange( usingResource, 1 ) )
{
Console::WriteLine( " {0} acquired the lock", Thread::CurrentThread->Name );
//Code to access a resource that is not thread safe would go here.
//Simulate some work
Thread::Sleep( 500 );
Console::WriteLine( " {0} exiting lock", Thread::CurrentThread->Name );
//Release the lock
Interlocked::Exchange( usingResource, 0 );
return true;
}
else
{
Console::WriteLine( " {0} was denied the lock", Thread::CurrentThread->Name );
return false;
}
}
//0 for false, 1 for true.
static int usingResource;
static Object^ globalMso = gcnew Object;
};
int main()
{
Thread^ myThread;
Random^ rnd = gcnew Random;
for ( int i = 0; i < numThreads; i++ )
{
myThread = gcnew Thread( gcnew ThreadStart( MyInterlockedExchangeExampleClass::MyThreadProc ) );
myThread->Name = String::Format( "Thread {0}", i + 1 );
//Wait a random amount of time before starting next thread.
Thread::Sleep( rnd->Next( 0, 1000 ) );
myThread->Start();
}
}
package InterlockedExchange_Example ;
import System .* ;
import System.Threading .* ;
import System.Threading.Thread;
class MyInterlockedExchangeExampleClass
{
//0 for false, 1 for true.
private static int usingResource = 0;
private static Object currentMso;
private static Object globalMso = new Object();
private static int numThreadIterations = 5;
private static int numThreads = 10;
public static void main(String[] args)
{
Thread myThread;
Random rnd = new Random();
for (int i = 0; i < numThreads; i++) {
myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.set_Name(String.Format("Thread{0}",
String.valueOf(i + 1)));
//Wait a random amount of time before starting next thread.
Thread.Sleep(rnd.Next(0, 1000));
myThread.Start();
}
} //main
private static void MyThreadProc()
{
for (int i = 0; i < numThreadIterations; i++) {
UseResource();
//Wait 1 second before next attempt.
Thread.Sleep(1000);
}
} //MyThreadProc
//A simple method that denies reentrancy.
static boolean UseResource()
{
//0 indicates that the method is not in use.
if (0 == Interlocked.Exchange(usingResource, 1)) {
Console.WriteLine("{0} acquired the lock",
Thread.get_CurrentThread().get_Name());
//Code to access a resource that is not thread safe would go here.
//Simulate some work
Thread.Sleep(500);
Console.WriteLine("{0} exiting lock",
Thread.get_CurrentThread().get_Name());
//Release the lock
Interlocked.Exchange(usingResource, 0);
return true;
}
else {
Console.WriteLine(" {0} was denied the lock",
Thread.get_CurrentThread().get_Name());
return false;
}
} //UseResource
} //MyInterlockedExchangeExampleClass
Vererbungshierarchie
System.Object
System.Threading.Interlocked
Threadsicherheit
Dieser Typ ist threadsicher.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
Interlocked-Member
System.Threading-Namespace