问无法将项目入队到抽象类中使用的BlockingCollection
EN

Stack Overflow用户

提问于 2020-09-14 13:12:57

回答 1查看 34关注 0票数 0

正如标题所暗示的那样，我利用一个抽象类来创建一个可重用的基类，用于使用BlockingCollection添加和删除项。我使用生产者/消费者模式来入队和出队，抽象类是通用的，所以我可以为队列指定一个对象。

我的问题发生在我调用基类入队和出队方法时，它们似乎引用了队列的另一个实例，即当我调用出队时队列上没有项，入队TryAdd()返回true。但是，当我直接在queue实例上调用Add或Take时，它工作得很好。

有人能告诉我为什么基类入队和出队方法不能像我预期的那样工作吗?我已经尝试过查找BlockingCollections的几个用法，但看不出原因。

Program.cs

static void Main(string[] args)
{

    var processor = new Processor(1,4);

    Console.ReadKey();
}

抽象基类

public abstract class BaseProcessor<T>: IDisposable
{
    protected BlockingCollection<T> _queue;
    private CancellationTokenSource _tokenSource;
    private int _producers;
    private int _consumers;
    private List<Task> _tasks;

    public BaseProcessor(int producers, int consumers)
    {
        _queue = new BlockingCollection<T>();
        _tokenSource = new CancellationTokenSource();
        _producers = producers;
        _consumers = consumers;
        _tasks = new List<Task>();
    }

    protected void Setup()
    {
        Parallel.For(0, _producers, i =>
            _tasks.Add(Task.Factory.StartNew(() => Produce(_tokenSource.Token), _tokenSource.Token)
            .ContinueWith((task) =>
            {
                Console.WriteLine("Task {0} stopped", task.Id);
            }))
         );

        Parallel.For(0, _producers, i =>
            _tasks.Add(Task.Factory.StartNew(() => Consume(_tokenSource.Token), _tokenSource.Token)
            .ContinueWith((task) =>
            {
                Console.WriteLine("Task {0} stopped", task.Id);
            }))
         );
    }

    protected abstract void Produce(CancellationToken token);
    protected abstract void Consume(CancellationToken token);

    protected void Enqueue(T item)
    {
        try
        {
            var res = _queue.TryAdd(item, TimeSpan.FromSeconds(1));
        }
        catch (Exception ex)
        {
            Console.WriteLine("Could not add item to queue: {0}", ex);
        }
    }

    protected void Enqueue(List<T> items)
    {
        items.ForEach(o => Enqueue(o));
    }

    protected T Dequeue()
    {
        try
        {
            T item;
            while (_queue.TryTake(out item, TimeSpan.FromSeconds(1))) ;
            return item;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Could not remove item to queue: {0}", ex);
            return default(T);
        }
    }


    public void Dispose()
    {
        // Cancel all tokens
        _tokenSource.Cancel();

        // Wait for all tasks complete
        Task.WaitAll(_tasks.ToArray());

        _queue.Dispose();
    }
}

抽象类实现

public class Processor: BaseProcessor<QueueItem>
{

    private int _counter;

    public Processor(int producers, int consumers): base(producers, consumers)
    {
        _counter = 0;

        Setup();
    }

    protected override void Produce(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {

            var queueItem = new QueueItem()
            {
                Id = _counter,
                Timestamp = DateTime.Now
            };

            //Enqueue(queueItem);
            _queue.Add(queueItem);

            Console.WriteLine("Enqueued: {0}", _counter);
            _counter++;

            Thread.Sleep(3000);
        }
    }

    protected override void Consume(CancellationToken token)
    {
        while (!token.IsCancellationRequested)
        {
            var item = Dequeue();
            //var item = _queue.Take();
            Console.WriteLine("Dequeued: {0}", item.Id);                
        }
    }
}