La palabra clave volatile es una de esas palabras clave muy pocas veces comprendidas, la documentación presente en msdn permite concluir que hay que utilizarla siempre que se manejen hilos, pero esto no siempre es así. Sin embargo lograr identificar que es lo que hace realmente esta palabra clave es una labor complicada así que dedicaré este artículo a explorar esta funcionalidad y a crear un ejemplo práctico que permita entender su verdadera naturaleza.
La documentación msdn
En msdn encontramos la siguiente definición de la palabra clave volatile:
| La palabra clave volatile indica que varios subprocesos que se ejecutan a la vez pueden 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 |
información completa
Debemos resaltar dos aspectos importantes de ese texto:
- Se menciona que los campos volatile no son susceptibles de optimizaciones por parte del compilador. Cuales optimizaciones?
- Dice que esto garantiza que el valor más actualizado siempre esta presente en el campo. No se supone que esto es así siempre?
A continuación revisaremos estas dos preguntas.
Optimizaciones del compilador
Siempre que compilamos un programa hecho con C# el compilador se encarga de convertir ese código C# en código de lenguaje IL, bueno realmente en OpCodes de IL. Esto es así de sencillo, pero resulta que cuando compilamos nuestro código en la configuración release o más específicamente cuando se marca la casilla de Optimizar código en el proyecto (ver imagen) el compilador realiza una revisión general del código par determinar que cosas puede hacer funcionar de una manera mejor a la que codificó el programador inicialmente o incluso como puede cambiar las cosas en el ejecutable que no están en manos del programador ni del propio lenguaje para que a la hora de ejecutarse el programa sea más eficiente.
Estas optimizaciones son calculadas por el compilador haciendo uso de un complejo juego de reglas algunas de las cuales dependen de la arquitectura del procesador ( x86, x64, IA64, etc) y algunas otras del modelo de memoria que se esta trabajando. Los modelos de memoria son un tema complejo incluso desde sus fundamentos si bien no es algo imposible de aprender, pero quien quiera puede profundizar un poco más al respecto puede leer el libro de Sistemas Operativos Modernos de Andrew Tanembaum y desde luego buscar referencias adicionales en internet.
Adicionalmente a las optimizaciones realizadas por el compilador de C# tenemos una segunda etapa de compilación y optimizaciones realizadas por el JIT al momento de ejecutarse el programa, las cuales tiene su propio conjunto de reglas algunas de las cuales también están influenciadas por la arquitectura del procesador y el modelo de memoria.
El Valor Actualizado
Parte de las optimizaciones realizadas por el compilador pueden evitar que en algún momento determinado los campos de memoria donde se encuentran las variables no sean actualizados con su valor más reciente, porque?
Cada vez que el procesador hace una operación necesita colocar el valor de las variables en uno de sus registros, de tal forma que si tenemos por ejemplo un bucle con una suma de esta manera:
int i = 0;
while (condicion)
{
i = i + 1;
}
El procesador enviaría el valor de “i” a uno de sus registros y el valor ”1” en otro registro, al obtener el valor de la suma el procesador debe colocar este valor de nuevo en memoria en la variable “i” de tal forma que al continuar el bucle todo el proceso se repite.
Esta secuencia sin embargo puede ser optimizada por el compilador ya que se hace innecesario que el valor de “i” sea copiado de los registros de la CPU a la memoria y viceversa tantas veces como dure el bucle, así que el compilador genera un código ejecutable que permite que los cálculos sean hechos en su totalidad en los registros de la CPU y solo hasta salir del bucle estos datos serian copiados de nuevo a la memoria.
Este tipo de optimizaciones que usan ”cache” trae una mejora considerable en la ejecución de procesos intensivos a nivel matemático y funcionan bastante bien en la mayoría de los escenarios.
Optimizaciones de cache y el problema de los hilos
Cuando el compilador esta realizando las optimizaciones analiza (de acuerdo a los estándares) todo lo que pueda hacer referencia a las variables en el contexto de ‘subproceso’ actual ( realmente en la mayoría de sistemas operativos no se ejecutan los procesos sino los subprocesos y se le llama proceso a un grupo de subprocesos que comparten la memoria ), así que con base a lo analizado realiza las optimizaciones, por ello el problema surge cuando un hilo trata de acceder a una variable que esta siendo modificada por un objeto que se ejecuta en un hilo diferente, ya que es posible que el hilo dueño de la variable se encuentre en medio de un proceso optimizado para funcionar por cache en los registros y al no estar verificando el valor de la variable en memoria pues no vera los cambios realizados, de hecho los sobrescribirá al finalizar. Así que en escenarios donde existan múltiples hilos lo ideal es bloquear este tipo de optimizaciones y estar muy atento a los casos donde no sea conveniente inactivarlas pues hay casos para todo.
El Ejemplo
Bien después de la teoría veamos la práctica, veremos ejemplos donde volatile no sirve para nada ( y creo que son la mayoría de casos en el mundo real – al menos en CPUs x86 ya que en IA64 al parecer el tema es muy diferente), y finalmente un caso que de acuerdo a la teoría que acabamos de ver funcionara perfectamente desde que lo compiles para x86.
Sobra decir que para probar los ejemplos lo debes hacer con la versión Release del ejecutable.
Ejemplo 1
Este es el ejemplo típico, donde todos usamos volatile porque así lo dice la documentación pero la realidad es que en estos casos no sirve de NADA.
using System.Threading;
using System;
static class BackgroundTaskDemo
{
//volatile
static int i = 0;
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
i++;
Console.WriteLine("Valor de i="+i);
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Podríamos ponerle a “i” como volatile pero no habría diferencia puesto que básicamente el código no necesita ni tiene como ser optimizado. Así que volatile no bloquearía ninguna optimización.
Ejemplo 2
Este es el ejemplo tampoco sirve de NADA, si bien en el bucle se ve la necesidad de optimizar el rendimiento del código evitando que se copie el valor de “i” o de “stopping” de los registros de la CPU a la memoria y viceversa resulta que al convertir “i” a string estamos forzando al compilador a que no utilice el cache dado que necesita el valor mas reciente de “i” en la memoria para poder llamar el método ToString() y al método WriteLine, adicionalmente al llamar a alguno de esos métodos se requiere colocar en los registros de la CPU los valores necesarios para cambiar de contexto y para poder ejecutar las operaciones internas de dichos métodos, así que no hay manera de optimizar nada.
using System.Threading;
using System;
static class BackgroundTaskDemo
{
//volatile
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
while (!stopping)
{
i++;
Console.WriteLine("Valor de i=" + i.ToString());
}
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Nuevamente podríamos ponerle a “i” como volatile pero no habría diferencia puesto que básicamente el código no necesita ni tiene como ser optimizado. Así que volatile no bloquearía ninguna optimización.
Ejemplo 3
En este SI que funcionan las optimizaciones, ya que el compilador optimizara el uso de “i” para que se apoye en los registros del procesador de principio a fin, eso es perfecto!, pero por otro lado “stopping” también es optimizado, trayendo como resultado que siempre este en uno de los registros y por tanto nunca se entere en que momento “stopping” cambio de valor para que saliera del bucle.
using System.Threading;
using System;
static class BackgroundTaskDemo
{
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
while (!stopping)
{
i++;
Console.WriteLine("Valor de i=" + i.ToString());
}
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Al ejecutar la version release para x86 de este programa veremos como, aunque en codigo parece que todo saldra bien, al ejecutarse el programa este nunca terminara pues el hilo nunca se entera que “stopping” cambio su valor. En pantalla veriamos perpetuamente
Main Exit
Y nada más 
Ese es el ejemplo perfecto de la funcionalidad de volatile, así que podemos ahora marcar el campo “stopping” como volatile, compilar y ejecutar la versión release… y AHORA SI FUNCIONA COMO DEBERIA DE SER!!!
using System.Threading;
using System;
static class BackgroundTaskDemo
{
private volatile static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
while (!stopping)
{
i++;
Console.WriteLine("Valor de i=" + i.ToString());
}
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Ahora si en pantalla veríamos
Main Exit
EfectuarTrabajo exit xxxxxxxx
Ejemplo 4
Este es el mismo ejemplo un poco mas elaborado haciendo uso de algunas operaciones de System.Math las cuales son suceptibles de optimización:
using System.Threading;
using System;
static class BackgroundTaskDemo
{
//volatile
private static bool stopping = false;
static void Main ()
{
new Thread(EfectuarTrabajo).Start();
Thread.Sleep(5000);
stopping = true;
Console.WriteLine("Main exit");
Console.ReadLine();
}
static void EfectuarTrabajo()
{
int i = 0;
int j = 2;
while (!stopping)
{
i++;
j = 100 + (int)Math.Sin((double)i * 10d);
}
Console.WriteLine("EfectuarTrabajo exit " + i);
}
}
Prueben quitando y poniendo volatile y verán la diferencia.
Eso es todo.
Hasta pronto.
Fuente: http://juank.black-byte.com/c-explicacion-ejemplo-volatile/
, luego debe aparecer las información relacionado con la plantilla y es ahi donde por cada elemento debemos incluir en proyecto o Include in Project: 
y finalmente se completa como:
.
Microsoft Surface Globe, con esta aplicacion se puede tener el mundo en la palma de las manos,pueden ver el funcionamiento en este 
Microsoft Surface Lagoon es un salvapantallas que puede interactuar con el uso del Touch Screen. Este salvapantallas recrea el entorno natural de un lago y un banco de peces.
Entradas
