AutoResetEvent и несколько наборов

Вам лучше использовать блокирующую коллекцию, если только вы не пытаетесь понять, как работает многопоточность. Это даст вам блокирующую коллекцию, поддерживаемую стеком:

ConcurrentStack<SomeType> MyStack = new ConcurrentStack<SomeType>();
BlockingCollection<SomeType> SharedStack = new BlockingCollection<SomeType>(MyStack)

Затем вы можете получить к нему доступ потокобезопасным способом со всей блокировкой, выполненной для вас должным образом. См. здесь

Вы можете использовать sharedStack, вызвав sharedStack.Take(), который затем заблокирует получение, пока не будет что-то взять из стека.

Редактировать: мне потребовалось некоторое время (и две попытки), но я думаю, что я решил вашу проблему.

Рассмотрим пустой стек с 3 потоками, ожидающими события.

Add вызывается, в стеке есть один объект, и через событие разрешен один поток.

Немедленно Add вызывается снова.

Теперь первый поток ожидает получения блокировки от Add.

Add добавляет второй объект в стек и позволяет другому потоку пройти через событие.

Теперь два объекта в стеке и 2 потока через событие, оба ожидают блокировки.

Поток First Get теперь блокируется и извлекается. Видит еще один объект в стеке и ВЫЗЫВАЕТ SET.

Третий поток разрешен через событие.

Второй поток Get теперь блокируется и извлекается. Ничего не видит в стеке и не вызывает set.

НО. Это очень поздно. Третий поток уже пропущен, поэтому, когда второй поток снимает блокировку, третий поток пытается извлечь из пустого стека и выбрасывает.

Нет, ваш текущий код не имеет смысла. На данный момент вы блокируете поток каждый раз, когда вызывается метод Get (вызов .WaitOne).

Возможно, вам нужно что-то вроде:

public class BlockingStack<T>
{
    private Stack<T> _internalStack;
    private AutoResetEvent _blockUntilAvailable;

    public BlockingStack()
    {
        _internalStack = new Stack<T>(5);
        _blockUntilAvailable = new AutoResetEvent(false);
    }

    public T Pop()
    {
        lock (_internalStack)
        {
            if (_internalStack.Count == 0)
                _blockUntilAvailable.WaitOne();

            return _internalStack.Pop();
        }
    }

    public void Push(T obj)
    {
        lock (_internalStack)
        {
            _internalStack.Push(obj);

            if(_internalStack.Count == 0)
                _blockUntilAvailable.Set();
        }
    }
}

Идея в том, что если текущее количество элементов в _internalStack равно 0, то он должен ждать сигнала от метода Push. Получив сигнал, он движется дальше и извлекает элемент из стека.

EDIT: в приведенном выше коде есть две проблемы:

1. Всякий раз, когда Pop блокируется с .WaitOne, он не освобождает блокировку _internalStack, и поэтому Push никогда не сможет получить блокировку.

2. Когда Pop вызывается несколько раз в одном и том же потоке, они имеют одно и то же начальное состояние для AutoResetEvent — например. Push сигнализирует AutoResetEvent о добавлении элемента. Теперь, когда я извлекаю элемент, он работает нормально в первый раз, так как на самом деле элемент находится в Stack. Однако во второй раз в Stack нет значения, поэтому он ожидает, вызвав .WaitOne в AutoResetEvent, но, поскольку вызов Push сигнализировал об этом событии, он просто вернет true, а не будет ждать, как ожидалось.

(Рабочая) альтернатива:

public class BlockingStack<T>
{
    private Stack<T> _internalStack;

    public BlockingStack()
    {
        _internalStack = new Stack<T>(5);
    }

    public T Pop()
    {
        lock (_internalStack)
        {
            if (_internalStack.Count == 0)
                Monitor.Wait(_internalStack);

            return _internalStack.Pop();
        }
    }

    public void Push(T obj)
    {
        lock (_internalStack)
        {
            _internalStack.Push(obj);
            Monitor.Pulse(_internalStack);
        }
    }
}

Я не проверял решение на основе Monitor, но написал решение на основе семафора, которое, похоже, работает:

public class Semaphore
{
    private int _count;
    private int _maximum;
    private object _countGuard;

    public Semaphore(int maximum)
    {
        _count = 0;
        _maximum = maximum;
        _countGuard = new object();
    }

    public void WaitOne()
    {
        while (true)
        {
            lock (_countGuard)
            {
                if (_count < _maximum)
                {
                    _count++;
                    return;
                }
            }
            Thread.Sleep(50);
        }
    }

    public void ReleaseOne()
    {
        lock (_countGuard)
        {
            if (_count > 0)
            {
                _count--;
            }
        }
    }
}

public class BlockingStack
{
    private Stack<MyType> _internalStack;
    private Semaphore _blockUntilAvailable;

    public BlockingStack()
    {
        _internalStack = new Stack<MyType>(5);
        _blockUntilAvailable = new Semaphore(5);

        for (int i = 0; i < 5; ++i)
        {
            var obj = new MyType();
            Add(obj);
        }
    }

    public MyType Get()
    {
        _blockUntilAvailable.WaitOne();

        lock (_internalStack)
        {
            var obj = _internalStack.Pop();
            return obj;
        }
    }

    public void Add(MyType obj)
    {
        lock (_internalStack)
        {
            _internalStack.Push(obj);
            _blockUntilAvailable.ReleaseOne();
        }
    }
}