Desde las palabras de MS, las lecturas y escrituras (junto con otras operaciones) hasta los dobles no son atómicos y, por lo tanto, no son seguros para subprocesos. Quería ver si puedo hacer que las lecturas y escrituras en subprocesos dobles sean seguras encuadrando los valores dobles y haciendo que la referencia al valor encuadrado sea volátil. A continuación hay una clase que demuestra mi uso de dobles en caja en un hilo trabajado y de consumo:

 public class Program { public volatile static object objCounter; public static AutoResetEvent Finish = new AutoResetEvent(false); static void Main(string[] args) { // Worker thread that writes to the boxed double values Task.Run(() => { double dCounter = 0d; while (!Finish.WaitOne(100, false)) { dCounter += 1.5d; // Box dCounter into objCounter - // Copy double value to new location on the heap // and point the objCounter to this location on the heap objCounter = (object)dCounter; } }); // Consumer thread that reads the boxed double values for (int index = 0; index < 50; index++) { Console.WriteLine(String.Format("Double counter value = {0}",objCounter)); Thread.Sleep(100); } Finish.Set(); } }

Creo que el código anterior es seguro para subprocesos por las siguientes razones:

1. Cuando el subproceso de trabajo escribe el doble en objCounter , debe crear una nueva ubicación en el montón, copiar el valor doble en esa nueva ubicación en el montón y luego copiar atómicamente la referencia a la nueva ubicación del montón en objCounter . Se garantiza que esta copia atómica de la referencia (puntero) a objCounter es atómica directamente desde la boca de MS: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/variables #96-atomicity-of-variable-references – (Consulte 9.6 Atomicity of variable references) Es importante tener en cuenta que se crea una nueva ubicación en el montón cada vez que encuadramos el doble, si no creamos una nueva ubicación en el montón que esto no sería seguro para subprocesos.

2. Dado que objCounter es volátil, no habría problemas de visibilidad de memoria entre los subprocesos de trabajo y de consumidor de la referencia que apunta a la ubicación de memoria en el montón que contiene el valor doble actual.

¿Estoy en lo correcto al suponer que mi uso de dobles en caja en un subproceso de trabajador y consumidor como se especificó anteriormente es seguro para subprocesos?