Kyç me kokë të vogël ose pa kyçje

Unë kam një rresht të njëkohshëm që mbushet me objekte nga një thread dhe një fill tjetër merr objekte prej tij dhe i përpunon ato.

Nëse radha bëhet e madhe, mund ta "kompres" atë duke hequr dublikatat. Kompresimi merr radhën dhe e bën atë në një listë, përsëritet përmes saj dhe krijon një radhë të re që kanë vetëm vlera të dallueshme. Kështu që unë zëvendësoj radhën dhe meqenëse e bëj këtë, nuk mund të futen objekte në radhën që mbishkruhen, do t'i humbas ato.

Problemi im është nëse shtoj një lock(obj) {} ose një lloj LockHandle, unë humbas shumë performancë. Ka shumë transaksione, por koha e përpunimit është shumë e ulët, kështu që mbyllja duket si ajo që po vret performancën time.

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();
            }
        }
    }
}

A mund të bëhet kjo pa u kyçur? A mund të përdor një bllokues më të lehtë? Deri më tani ka vetëm një thread që shton të dhëna dhe një thread që lexon. Dhe unë mund ta mbaj në këtë mënyrë nëse kjo më bën një bllokim më të mirë.