Código asincrónico, variables compartidas, subprocesos de grupo de subprocesos y seguridad de subprocesos

Cuando escribo código asincrónico con async / await, generalmente ConfigureAwait(false)para evitar capturar el contexto, mi código salta de un subproceso de grupo de subprocesos al siguiente después de cada uno await. Esto plantea preocupaciones sobre la seguridad del hilo. ¿Es seguro este código?

static async Task Main()
{
    int count = 0;
    for (int i = 0; i < 1_000_000; i++)
    {
        Interlocked.Increment(ref count);
        await Task.Yield();
    }
    Console.WriteLine(count == 1_000_000 ? "OK" : "Error");
}

La variable ino está protegida y se accede a ella mediante múltiples subprocesos de grupo de subprocesos *. Aunque el patrón de acceso no es concurrente, debería ser teóricamente posible que cada subproceso incremente un valor almacenado localmente en caché i, lo que da como resultado más de 1,000,000 de iteraciones. Sin embargo, no puedo producir este escenario en la práctica. El código anterior siempre imprime OK en mi máquina. ¿Esto significa que el código es seguro para subprocesos? ¿O debería sincronizar el acceso a la ivariable usando a lock?

(* un cambio de hilo ocurre cada 2 iteraciones en promedio, de acuerdo con mis pruebas)

El problema con la seguridad del hilo es sobre la lectura / escritura de memoria. Incluso cuando esto podría continuar en un hilo diferente, aquí nada se ejecuta simultáneamente.

Creo que este artículo de Stephen Toub puede arrojar algo de luz sobre esto. En particular, este es un pasaje relevante sobre lo que sucede durante un cambio de contexto:

Cada vez que el código espera a un esperable cuyo camarero dice que aún no está completo (es decir, el IsCompleted del camarero devuelve falso), el método debe suspenderse y se reanudará a través de una continuación del camarero. Este es uno de esos puntos asincrónicos a los que me referí anteriormente, y por lo tanto, ExecutionContext necesita fluir desde el código que emite la espera hasta la ejecución del delegado de continuación. Eso lo maneja automáticamente el Framework. Cuando el método asíncrono está a punto de suspenderse, la infraestructura captura un ExecutionContext. El delegado que se pasa al camarero tiene una referencia a esta instancia de ExecutionContext y la usará cuando reanude el método. Esto es lo que permite que la información importante "ambiental" representada por ExecutionContext fluya a través de las esperas.

Vale la pena señalar que el YieldAwaitabledevuelto por Task.Yield()siempre regresa false.