volatile (C#-Referenz)
Das volatile-Schlüsselwort gibt an, dass ein Feld von mehreren gleichzeitig ausgeführten Threads geändert werden kann. Mit volatile deklarierte Felder unterliegen nicht den Compileroptimierungen, für die der Zugriff durch einen Thread Voraussetzung ist. Auf diese Weise wird sichergestellt, dass im Feld stets der aktuelle Wert vorhanden ist.
Der volatile-Modifizierer wird normalerweise für ein Feld verwendet, auf das mehrere Threads zugreifen, ohne dass die lock-Anweisung zur Zugriffsserialisierung verwendet wird.
Das volatile-Schlüsselwort kann auf Felder der folgenden Typen angewendet werden:
Referenztypen.
Zeigertypen (in einem unsicheren Kontext) Beachten Sie, dass der Zeiger flüchtig sein kann, das Objekt, auf den er zeigt, jedoch nicht. Mit anderen Worten können Sie keinen "Zeiger auf volatile" deklarieren.
Typen wie sbyte, byte, short, ushort, int, uint, char, float und bool.
Ein Enumerationstyp mit einem der folgenden Basistypen: byte, sbyte, short, ushort, int oder uint.
Generische Typparameter, von denen bekannt ist, dass sie Referenztypen sind.
Das volatile-Schlüsselwort kann nur auf Felder einer Klasse oder Struktur angewendet werden. Lokale Variablen können nicht als volatile deklariert werden.
Beispiel
Im folgenden Beispiel wird veranschaulicht, wie eine public-Feldvariable als volatile deklariert wird.
class VolatileTest
{
public volatile int i;
public void Test(int _i)
{
i = _i;
}
}
Im folgenden Beispiel wird veranschaulicht, wie ein Hilfs- bzw. Arbeitsthread erstellt und für die Verarbeitung parallel zum primären Thread verwendet werden kann. Hintergrundinformationen zum Multithreading finden Sie unter Verwaltetes Threading und Threading (C# und Visual Basic)
using System;
using System.Threading;
public class Worker
{
// This method is called when the thread is started.
public void DoWork()
{
while (!_shouldStop)
{
Console.WriteLine("Worker thread: working...");
}
Console.WriteLine("Worker thread: terminating gracefully.");
}
public void RequestStop()
{
_shouldStop = true;
}
// Keyword volatile is used as a hint to the compiler that this data
// member is accessed by multiple threads.
private volatile bool _shouldStop;
}
public class WorkerThreadExample
{
static void Main()
{
// Create the worker thread object. This does not start the thread.
Worker workerObject = new Worker();
Thread workerThread = new Thread(workerObject.DoWork);
// Start the worker thread.
workerThread.Start();
Console.WriteLine("Main thread: starting worker thread...");
// Loop until the worker thread activates.
while (!workerThread.IsAlive) ;
// Put the main thread to sleep for 1 millisecond to
// allow the worker thread to do some work.
Thread.Sleep(1);
// Request that the worker thread stop itself.
workerObject.RequestStop();
// Use the Thread.Join method to block the current thread
// until the object's thread terminates.
workerThread.Join();
Console.WriteLine("Main thread: worker thread has terminated.");
}
// Sample output:
// Main thread: starting worker thread...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: working...
// Worker thread: terminating gracefully.
// Main thread: worker thread has terminated.
}
C#-Programmiersprachenspezifikation
Weitere Informationen finden Sie in der C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.