Esta es una pregunta avanzada en subprocesos múltiples de C#.
Digamos que tengo este código que se usa como mecanismo de bloqueo para habilitar solo un subproceso para iniciar alguna operación:
private static int _guard = 0; private static bool acquire() { return Interlocked.CompareExchange(ref _guard, 1, 0) == 0; } private static void release() { Volatile.Write(ref _guard, 0); }Este bloqueo se usa para proteger el método que debe ejecutar solo un subproceso a la vez:
public readonly Status Status = new (); // updated from thread that runs someTask void TryRunningTask { if (acquire()) { return await someTask(); } else { InfoMessage = "Another user is currently running someTask."; } } Mi pregunta es, si cambio release() de la siguiente manera:
private static void release() { _guard = 0; }¿Seguiría el programa comportándose completamente igual? ¿Eso rompería la seguridad del hilo? ¿Tendría algún sentido este cambio?
El razonamiento detrás de mi idea para este cambio es el siguiente:
release() . En MS Docs para el método Volatile.Write dice:Escribe un valor en un campo. En los sistemas que lo requieren, inserta una barrera de memoria que evita que el procesador reordene las operaciones de memoria de la siguiente manera: si aparece una lectura o escritura antes de este método en el código, el procesador no puede moverla después de este método.
Entonces, debido a que mi método release() no tiene otras operaciones antes/después de la llamada Volatile.Write() , supongo que puedo reemplazarlo con una declaración de asignación simple _guard = 0; ¿Correcto?
_guard = 0; Se garantiza que la operación sea atómica:10.6 Atomicidad de referencias variables
Las lecturas y escrituras de los siguientes tipos de datos deben ser atómicas: bool, char, byte, sbyte, short, ushort, uint, int, float y tipos de referencia.
No, no puede eliminar la llamada a Volatile.Write .
Tiene razón con respecto al punto de atomicidad: C # y CLR exigen que los tipos de datos de 32 bits y más pequeños sean atómicos.
Sin embargo, no solo hay que considerar la atomicidad. También hay que tener en cuenta el reordenamiento de instrucciones y el almacenamiento en caché del procesador.
El reordenamiento puede ocurrir por CLR Jitter, y el tamaño de su función no es relevante, ya que puede estar en línea en cualquier función que la llame (y probablemente se le dé su brevedad).
El procesador también puede reordenar instrucciones, si se ajusta a las instrucciones que se le han dado.
Entonces esto necesita una barrera de memoria para ser seguro para subprocesos.
El almacenamiento en caché del procesador es otro problema: si no se le dice al núcleo del procesador que una lectura o escritura es volátil, podría usar su propio caché e ignorar lo que hay en los cachés de otros núcleos.
Pero, Volatile.Write puede no ser suficiente de todos modos. No puedo decir exactamente por lo que has mostrado, pero parece que tienes varios subprocesos que leen y escriben. Creo que, por lo tanto, debería usar Interlocked.Exchange en su lugar.