Неустойчивость доступа к общей памяти между запросами в ASP.NET Core

Эрик Липперт упомянул в этом посте в блоге несколько лет назад, что:

Компилятору C#, JIT-компилятору и процессору разрешено выполнять оптимизацию при условии, что оптимизация не обнаруживается текущим потоком. В частности, операции чтения и записи переменных могут быть переупорядочены или полностью исключены при условии, что это не будет наблюдаться в текущем потоке.

Это означает, что следующая программа может законно войти в бесконечный цикл, потому что мутация в x никогда не наблюдается основным потоком (и на самом деле в .NET 6 это действительно происходит при сборке Release на моей машине):

class Program
{
    static void Main(string[] args)
    {
        int x = 0;
        int z = 0;
        Task.Run(() =>
        {
            Thread.Sleep(1000);
            x = 1;
        });

        while (x == 0)
            unchecked { z = z + 1; }
    }
}

Теперь мне интересно, в серверном приложении, таком как ASP.NET Core, которое по своей сути поддерживает параллелизм и является многопоточным, такое переупорядочивание компилятора/кэширование регистров или любые другие закулисные оптимизации могут привести к тонким ошибкам? Например, предположим, что у меня есть подобная одноэлементная служба, к которой обращаются одновременно, когда сервер обрабатывает запросы:

public class SingletonService
{
    private string _cachedValue;

    public async Task<string> GetStringValue()
    {
        if (IsValueExpired(_cachedValue))
        {
            _cachedValue = await GetNewValue();
        }
        return _cachedValue;
    }

    ...
}

// when configuring the DI services, e.g. in Startup.cs
services.AddSingleton<SingletonService>;

Возможно ли, чтобы мутация _cachedValue никогда не наблюдалась потоком обработки запросов, даже спустя долгое время после того, как значение было обновлено другим потоком? Если это так, то это означает, что этот тип кэширования подвержен тонким и трудно воспроизводимым ошибкам, и мне, вероятно, потребуется заключить чтение/запись _cachedValue в блокировки (которые, как я понимаю, обеспечивают барьеры памяти, которые гарантируют что мутации сбрасываются во все потоки).

В частности, я хотел бы знать, является ли комментарий Эрика выше по-прежнему правильным или актуальным в .NET Core/.NET 5+ и мире async/await сегодня? И если да, то как лучше всего кэшировать такие вещи в памяти в ASP.NET Core? Нужно ли мне для безопасности закрывать весь доступ к общей памяти блокировками?

P.S. Я понимаю разницу между «многозадачностью» и «многопоточностью» и понимаю, что конвейер обработки запросов в ASP.NET Core полностью асинхронен и не привязан к конкретному потоку. Но это не имеет отношения к вопросу выше, поэтому простите меня за использование термина «многопоточность» немного вольно.