volatile (Referencia de C#)
La palabra clave volatile indica que varios subprocesos que se ejecutan a la vez podrían modificar un campo. Los campos que se declaran como volatile no están sujetos a optimizaciones del compilador que suponen el acceso por un subproceso único. Esto garantiza que el valor más actualizado está en todo momento presente en el campo.
El modificador volatile suele utilizarse para un campo al que tengan acceso varios subprocesos sin utilizar la instrucción lock para serializar el acceso.
La palabra clave volatile se puede aplicar a los campos de estos tipos:
Tipos de referencia.
Tipos de puntero (en un contexto no seguro). Tenga en cuenta que aunque el propio puntero puede ser volátil, no ocurre lo mismo con el objeto al que apunta. Es decir, no puede declarar un "puntero como volátil".
Tipos como sbyte, byte, short, ushort, int, uint, char, float y bool.
Un tipo de enumeración con uno de los siguientes tipos base: byte, sbyte, short, ushort, int o uint.
Parámetros de tipo genéricos que se sabe que son tipos de referencia.
La palabra clave volatile sólo se puede aplicar a los campos de una clase o struct. Las variables locales no se pueden declarar como volatile.
Ejemplo
El ejemplo siguiente muestra cómo declarar una variable de campo pública como volatile.
class VolatileTest
{
public volatile int i;
public void Test(int _i)
{
i = _i;
}
}
En el ejemplo siguiente se muestra cómo crear un subproceso auxiliar o de trabajo, y utilizarlo para realizar el procesamiento en paralelo con el del subproceso primario. Para obtener información básica sobre multithreading, vea Subprocesamiento administrado y Subprocesamiento (C# y 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.
}
Especificación del lenguaje C#
Para obtener más información, consulte la Especificación del lenguaje C#. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.
Vea también
Referencia
Modificadores (Referencia de C#)