Шаблон производитель / потребитель с очередью FIFO фиксированного размера

Проще говоря, ConcurrentQueue имеет метод ToArray, который при вводе блокирует коллекцию и создает «моментальный снимок» всех текущих элементов в очереди. Если вы хотите, чтобы вашему потребителю был предоставлен блок вещей для работы, вы можете заблокировать тот же объект, что и метод постановки в очередь, вызовите ToArray (), а затем прокрутите цикл while(!queue.IsEmpty) queue.TryDequeue(out trash) для очистки очереди, прежде чем возвращать массив, который вы извлекли. .

Это будет ваш GetAll() метод:

public T[] GetAll()
{
    lock (syncObj) // so that we don't clear items we didn't get with ToArray()
    {
        var result = queue.ToArray();
        T trash;
        while(!queue.IsEmpty) queue.TryDequeue(out trash);
    }
}

Поскольку вам нужно очистить очередь, вы можете просто объединить две операции; создайте массив надлежащего размера (используя queue.Count), затем, пока очередь не пуста, удалите элемент из очереди и поместите его в массив перед возвратом.

Вот ответ на конкретный вопрос. Теперь я должен с чистой совестью надеть шляпу CodeReview.SE и указать на несколько вещей:

• НИКОГДА не используйте lock(this). Вы никогда не знаете, какие другие объекты могут использовать ваш объект как блокирующий фокус и, таким образом, будут заблокированы, когда объект блокируется изнутри. Лучше всего заблокировать экземпляр объекта с частной областью видимости, обычно созданный только для блокировки: private readonly object syncObj = new object();

• Поскольку вы все равно блокируете критические разделы своей оболочки, я бы использовал обычный List<T> вместо параллельной коллекции. Доступ быстрее, его легче очистить, поэтому вы сможете делать то, что делаете, гораздо проще, чем позволяет ConcurrentQueue. Для постановки в очередь заблокируйте объект синхронизации, вставьте () перед нулевым индексом, затем удалите все элементы из размера индекса до текущего счетчика списка с помощью RemoveRange (). Чтобы исключить из очереди, заблокируйте тот же объект синхронизации, вызовите myList.ToArray () (из пространства имен Linq; делает почти то же самое, что и ConcurrentQueue), а затем вызовите myList.Clear () перед возвратом массива. Не может быть проще:

  public class FixedSizeQueue<T>
  {
  private readonly List<T> queue = new List<T>();
  private readonly object syncObj = new object();
  
  public int Size { get; private set; }
  
  public FixedSizeQueue(int size) { Size = size; }
  
  public void Enqueue(T obj)
  {
      lock (syncObj)
      {
          queue.Insert(0,obj)
          if(queue.Count > Size) 
             queue.RemoveRange(Size, Count-Size);
      }
  }
  
  public T[] Dequeue()
  {
      lock (syncObj)
      {
          var result = queue.ToArray();
          queue.Clear();
          return result;
      }
  }
  }
  

• Кажется, вы понимаете, что с помощью этой модели вы выбрасываете элементы из очереди. Обычно это нехорошо, но я хочу дать вам преимущество в сомнениях. Однако я скажу, что есть способ добиться этого без потерь, используя BlockingCollection. BlockingCollection охватывает любую коллекцию IProducerConsumerCollection, включая большинство классов System.Collections.Concurrent, и позволяет указать максимальную емкость для очереди. Затем коллекция будет блокировать любой поток, пытающийся выйти из очереди из пустой очереди, или любой поток, пытающийся добавить в полную очередь, до тех пор, пока элементы не будут добавлены или удалены, чтобы было что получить или место для вставки. Это лучший способ реализовать очередь производитель-потребитель с максимальным размером или такую, которая в противном случае потребовала бы «опроса», чтобы увидеть, есть ли у потребителя над чем поработать. Если вы пойдете по этому маршруту, выбрасываются только те, которые потребитель должен выбросить; потребитель увидит все строки, добавленные производителем, и примет собственное решение по каждой.

Вы не хотите использовать lock с this. Дополнительные сведения см. В разделе Почему блокировка (это) {…} плохо?.

Этот код

// if queue count > max queue size, then dequeue an item
while (queue.Count > Size) 
{
    T objOut;
    queue.TryDequeue(out objOut);
}

предполагает, что вам нужно как-то подождать или уведомить потребителя о доступности товара. В этом случае рассмотрите возможность использования вместо этого BlockingCollection<T>.