Как возникает состояние гонки?

У меня есть реализация пула с одним элементом:

public class OneItemPool<T>
{
    private T? _item;
    private object _lockForChangeValue = new();
    private object _lockForPostItem = new();
    private object _lockForGetItem = new();

    public void PostItem(T item)
    {
        lock (_lockForPostItem)
        {
            // waiting for _item to be taken
            while (WeHaveItem())
            {
            }
            
            lock (_lockForChangeValue)
            {
                _item = item;
            }
        }
    }

    public T GetItem()
    {
        lock (_lockForGetItem)
        {
            // waiting for _item to appear
            while (!WeHaveItem())
            {
            }
            
            lock (_lockForChangeValue)
            {
                var item = _item;
                _item = default(T);
                return item;
            }
        }
    }
    
    bool WeHaveItem()
    {
        return !object.ReferenceEquals(_item, default(T));
    }
}

Как видите, у меня нет блокировки внутри bool WeHaveItem(), я знаю, что object.ReferenceEquals не является атомарной операцией.

Я знаю, что это может случиться:

• Поток А вызывает WeHaveItem() и видит, что _item имеет значение null
• Тем временем поток B меняет значение _item.
• Поток A продолжает выполнение, предполагая, что _item имеет значение null, хотя это больше не соответствует действительности.

Предположим, что _item не равно нулю и поток A вызывает PostItem, затем проверьте WeHaveItem и подождите, пока он станет нулевым
в то время как поток B вызывает GetItem и меняет _value на ноль
Поток А получит старый результат _item != null
но это вообще не должно влиять на поток A, потому что следующей операцией потока A будет перепроверка WeHaveItem

Я думаю, проблем не будет. Но реальные испытания показывают, что это не так.

Я настроил свой тест следующим образом

var pool = new OneItemPool<string>();
while (true)
{
    var threads = new List<Thread>();
    for (int i = 0; i < 3; i++)
    {
        var k = i;
        var thr1 = new Thread(() =>
        {
            pool.PostItem(k.ToString());
            pool.GetItem();
        });
        threads.Add(thr1);
    }


    foreach (var thread in threads)
    {
        thread.Start();
    } 
    foreach (var thread in threads)
    {
        thread.Join();
    }
}

Один PostItem за один GetItem, но тест заходит в тупик внутри PostItem, а значение _item не равно нулю.
Это показывает, что два GetItem успешно выполняются для одного PostItem.

Если я добавлю блокировку внутри WeHaveItem, взаимоблокировка исчезнет.

Я думаю об этом уже два дня и не представляю, как такое возможно.