Question

我有一个ConcurrentQueue，它从一个线程中填充对象，另一个线程从中获取对象并处理它们。

如果队列变大，我可以＆＃34;压缩＆＃34;它通过删除重复。压缩获取队列并使其成为一个列表，遍历它并创建一个只有不同值的新队列。所以我替换队列，因为我这样做，我不能将对象插入队列中被覆盖，我会松开它们。

我的问题是，如果我添加一个锁（obj）{}或某种类型的LockHandle我松散了很多性能。有很多交易，但处理时间非常短，所以锁定看起来就像是在扼杀我的表现。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using System.IO;

namespace A
{
    public abstract class Base
    {
        private ConcurrentQueue<Data> unProcessed = new ConcurrentQueue<Data>();

        private const int MIN_COLLAPSETIME = 30;
        private const int MIN_COLLAPSECOUNT = 1000;
        private QueueCollapser Collapser;
        private ManualResetEventSlim waitForCollapsing = new ManualResetEventSlim(true);
        private ManualResetEventSlim waitForWrite = new ManualResetEventSlim();

        // Thread signal.
        public AutoResetEvent unProcessedEvent = new AutoResetEvent(false);
        // exiting
        public volatile bool Exiting = false;

        private Task task;

        public BasePusher()
        {
            // initiate Collapser
            Collapser = new QueueCollapser();
            // set up thread
            task = new Task(
               () =>
               {
                   consumerTask();
               }, TaskCreationOptions.LongRunning
               );

        }

        public void Start()
        {
            task.Start();
        }

        private void consumerTask()
        {
            Data data = null;
            while (!Exiting)
            {
                try
                {
                        // do we try to collapse
                        if (unProcessed.Count > MIN_COLLAPSECOUNT && (DateTime.Now - Collapser.LastCollapse).TotalSeconds > MIN_COLLAPSETIME)
                        {
                            waitForCollapsing.Reset();
                            waitForWrite.Wait();
                            unProcessed = Collapser.Collapse(unProcessed);
                            waitForCollapsing.Set();
                            // tried this aswell instead of using my own locking, this is like Monitor.Enter
                            lock(this) {
                                unProcessed = Collapser.Collapse(unProcessed);
                            }
                        }
                        if (sum == 0)
                        {
                            // we wake the thread after 20 seconds, if nothing is in queue it will just go back and wait
                            unProcessedEvent.WaitOne(20000);
                        }
                        var gotOne = unProcessed.TryDequeue(out data);
                        if (gotOne)
                        {
                            ProcessTime(data);
                        }
                    }
                }
                catch (Exception e)
                {

                }
            }
        }

        protected abstract void ProcessTime(Data d);

        public void AddToQueue(Data d)
        {
            waitForCollapsing.Wait();
            waitForWrite.Reset();
            unProcessed.Enqueue(d);
            waitForWrite.Set();
            unProcessedEvent.Set();
        }

        // tried this aswell instead of using my own locking, this is like Monitor.Enter
        public void AddToQueueAlternate(Data d)
        {
            lock(this) {
                unProcessed.Enqueue(d);
                waitForWrite.Set();
                unProcessedEvent.Set();
            }
        }
    }
}

这可以不锁定吗？我可以使用更轻巧的锁吗？截至目前，只有一个线程添加数据和一个线程读取。如果能让我获得更好的锁定，我可以保持这种状态。

Answer 1

如果您想要并发且没有重复项，则应使用ConcurrentDictionary

重新宣布你的队列：

private ConcurrentDictionary<Data, Data> unProcessed = 
   new ConcurrentDictionary<Data, Data>();

这将大大简化您的代码，同时保持非常好的表现。

Answer 2

为什么你会有重复？

如果发布者可以真正添加重复项，那么您需要某种类型的并发哈希对象（Dictionary或HashSet）来检测并防止这种情况在发布者中出现。

您可能还想调查ReaderWriterLockSlim。

锁定小开销或无锁

2 个答案: