小开销锁或无锁

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

如果队列变大，我可以通过删除重复项来"压缩"它。压缩过程获取队列并将其放入一个列表中，对其进行迭代并创建一个只有不同值的新队列。所以我替换了队列，因为我不能将对象插入到被覆盖的队列中，所以我将丢失它们。

我的问题是，如果我添加一个锁(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();
            }
        }
    }
}

可以在没有锁的情况下完成吗?我可以使用更轻便的锁吗?到目前为止，只有一个线程添加数据和一个线程读取。如果我能得到一个更好的锁，我可以保持这个状态

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