C# volatil de subprocesos múltiples

concepto

La palabra clave volatile indica que un campo puede ser modificado por varios subprocesos que se ejecutan simultáneamente.

El compilador, el sistema de tiempo de ejecución e incluso el hardware pueden reorganizar las lecturas y escrituras en ubicaciones de memoria por motivos de rendimiento.

Los campos declarados volátiles están excluidos de ciertos tipos de optimizaciones.

muestra

public class Worker
{
    // This method is called when the thread is started.
    public void DoWork()
    {
        bool work = false;
        while (!_shouldStop)
        {
            work = !work; // simulate some work
        }
        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
{
    public 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 500 milliseconds to
        // allow the worker thread to do some work.
        Thread.Sleep(500);

        // 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: terminating gracefully.
    // Main thread: worker thread has terminated.
}

Agregar el modificador volatile a la declaración de _shouldStop siempre da el mismo resultado.
Sin embargo, sin este modificador en el miembro _shouldStop, el comportamiento es impredecible. El método DoWork puede optimizar el acceso de los miembros, lo que da como resultado lecturas de datos obsoletos.
Dada la naturaleza de la programación multiproceso, la cantidad de veces que se leen datos obsoletos es impredecible. Las diferentes ejecuciones del programa producirán algunos resultados diferentes.

Clase volátil

• En los sistemas multiprocesador, una operación de escritura volátil garantiza que el valor escrito en una ubicación de memoria sea inmediatamente visible para todos los procesadores. Una operación de lectura volátil obtiene el valor más reciente escrito en una ubicación de memoria por cualquier procesador. Estas operaciones pueden requerir el vaciado de las memorias caché del procesador, lo que puede afectar el rendimiento.

• En los sistemas monoprocesador, las lecturas y escrituras volátiles garantizan que los valores se lean o escriban en la memoria y no se almacenen en caché (por ejemplo, en los registros del procesador). Por lo tanto, puede usar estas operaciones para sincronizar el acceso a campos que pueden ser actualizados por otro hilo o por hardware.