En un programa multiproceso que se ejecuta en una máquina de varias CPU, necesito acceder al estado compartido (_data en el código de ejemplo a continuación) usando lecturas/escrituras volátiles para asegurar la corrección.Uso de volátiles (Thread.VolatileRead/Thread.VolatileWrite) en C#
En otras palabras, ¿se pueden almacenar en memoria caché los objetos en la CPU?
Utilizando el ejemplo siguiente y suponiendo que los subprocesos múltiples accederán a los métodos GetValue y Add, necesito que ThreadA pueda agregar datos (usando el método Add) y ThreadB para poder ver/obtener esos datos agregados inmediatamente (usando el método GetValue). Entonces, ¿necesito agregar lecturas/escrituras volátiles a _data para asegurar esto? Básicamente, no quiero que los datos agregados se almacenen en caché en la CPU de ThreadA.
/No estoy Bloqueando (imponiendo acceso exclusivo a subprocesos) ya que el código debe ser ultrarrápido y no estoy eliminando ningún dato de _data, así que no es necesario bloquear _data.
Gracias.
**** Actualización ****************************
Obviamente piensan ustedes va usando bloqueo libre este ejemplo es mala idea. Pero, ¿qué efectos secundarios o excepciones podría enfrentar aquí?
¿Podría el diccionario escribir una excepción si 1 hilo está iterando los valores de lectura y otro hilo está iterando los valores para la actualización? ¿O simplemente experimentaría "lecturas sucias" (que estaría bien en mi caso)?
**** End Actualizar ****************************
public sealed class Data
{
private volatile readonly Dictionary<string, double> _data = new Dictionary<string, double>();
public double GetVaule(string key)
{
double value;
if (!_data.TryGetValue(key, out value))
{
throw new ArgumentException(string.Format("Key {0} does not exist.", key));
}
return value;
}
public void Add(string key, double value)
{
_data.Add(key, value);
}
public void Clear()
{
_data.Clear();
}
}
Gracias por las respuestas Con respecto a las cerraduras, los métodos son llamados casi constantemente por varios hilos, por lo que mi problema es con los bloqueos disputados, no con la operación de bloqueo real.
Así que mi pregunta es sobre el almacenamiento en caché de la CPU, ¿pueden almacenarse en caché los objetos (el campo de la instancia _data) en una CPU? ¿Necesito acceder al campo _data usando lecturas/escrituras volátiles?
/Además, estoy atrapado con .Net 2.0.
Gracias por su ayuda.