Атомная безопасность потоков Производитель/потребитель

У меня есть приложение, которое использует шаблон производитель/потребитель для обработки событий (всего 2 потока). Основной поток (UI) атомарно записывает в поле ссылочного типа, а мой экземпляр потока атомарно считывает это поле. Вот демонстрационный код:

public class MyApp
{
    private Thread WorkerThread;        // Thread which processes the events.
    private EventArgs QueuedEvent;      // The latest event registered by the app.
    private EventArgs ProcessedEvent;   // The latest event processed by the worker.

    public static void Main(string[] args)
    {
        // Create and start the thread.
        WorkerThread = new(new ThreadStart(DoWork));
        WorkerThread.Start();

        // Attach event
        [...]
    }

    // Event which is fired from the main thread.
    // The timing of this event is unpredictable; 
    // it could be super fast, never fire, or anything in between.
    private static void OnEvent(object sender, EventArgs e)
    {
        // Set this as the latest event.
        // It is OK if the previous event is LOST.
        QueuedEvent = e;
    }

    // Main loop for consumer thread.
    private void DoWork()
    {
        while (true)
        {
            // Copy QueuedEvent to local variable so it's not overwritten.
            var argsToWorkOn = QueuedEvent;

            // For performance, don't do work if the args haven't changed.
            if (argsToWorkOn != ProcessedEvent)
            {
                // Do expensive work with argsToWorkOn.
                [...]

                // Remember that we already did work with these args.
                ProcessedEvent = argsToWorkOn;
            }
        }
    }
}

Вопрос

Производительность в обоих потоках здесь является приоритетом №1; они не должны блокировать друг друга. Учитывая это, какой объективно наиболее эффективный способ реализовать потокобезопасность? Это:

• Не обязательно? Точно нет. Если я не ошибаюсь.
• Использовать изменчивый? Это был мой первоначальный ответ. Но после нескольких часов исследований я, честно говоря, понятия не имею, какой сделать вывод относительно volatile здесь. Я читал аргументы за и против летучести, особенно в отношении современной архитектуры.
• Использовать блокировку? Может быть. Основной поток может блокироваться каждый раз, когда рабочий поток читает поле, а это плохо.
• Использовать взаимосвязанный? Я не думаю, что это очень применимо здесь, но я могу ошибаться.
• Использовать ReaderWriterLockSlim? На самом деле я еще не углублялся в это, я просто знаю, что оно существует.
• Что-то другое?