Question

Can anyone see any problems with this Producer/Consumer unique keyed buffer impl? The idea is if you add items for processing with the same key only the lastest value will be processed and the old/existing value will be thrown away.

public sealed class PCKeyedBuffer<K,V>
{
    private readonly object _locker = new object();
    private readonly Thread _worker;
    private readonly IDictionary<K, V> _items = new Dictionary<K, V>();
    private readonly Action<V> _action;
    private volatile bool _shutdown;

    public PCKeyedBuffer(Action<V> action)
    {
        _action = action;
        (_worker = new Thread(Consume)).Start();
    }

    public void Shutdown(bool waitForWorker)
    {
        _shutdown = true;
        if (waitForWorker)
                _worker.Join();
    }

    public void Add(K key, V value)
    {
        lock (_locker)
        {
            _items[key] = value;
            Monitor.Pulse(_locker);
        }
    }

    private void Consume()
    {
        while (true)
        {
            IList<V> values;
            lock (_locker)
            {
                while (_items.Count == 0) Monitor.Wait(_locker);
                values = new List<V>(_items.Values);
                _items.Clear();
            }
            foreach (V value in values)
            {
                 _action(value);
            }

            if(_shutdown) return;
        }
    }
}


    static void Main(string[] args)
    {
        PCKeyedBuffer<string, double> l = new PCKeyedBuffer<string, double>(delegate(double d)
                                                                                {
                                                                                    Thread.Sleep(10);
                                                                                    Console.WriteLine(
                                                                                        "Processed: " + d.ToString());
                                                                                });
        for (double i = 0; i < 100; i++)
        {
            l.Add(i.ToString(), i);
        }
        for (double i = 0; i < 100; i++)
        {
            l.Add(i.ToString(), i);
        }
        for (double i = 0; i < 100; i++)
        {
            l.Add(i.ToString(), i);
        }

        Console.WriteLine("Done Enqeueing");
        Console.ReadLine();
    }

Answer 1

After a quick once over I would say that the following code in the Consume method

while (_items.Count == 0) Monitor.Wait(_locker);

Should probably Wait using a timeout and check the _shutdown flag each iteration. Especially since you are not setting your consumer thread to be aq background thread.

In addition, the Consume method does not appear very scalable, since it single handedly tries to process an entire queue of items. Of course this might depend on the rate that items are being produced. I would probably have the consumer focus on a single item in the list and then use TPL to run multiple concurrent consumers, this way you can take advantage of multple cores while letting TPL balance the work load for you. To reduce the required locking for the consumer processing a single item you could use a ConcurrentDictionary