Выбор метода для модели Поставщик/получатель

using System;
using System.Threading;
using System.Collections.Concurrent;
using System.Collections.Generic;
 
namespace QueueTest
{
    class Program
    {
        
        static void Main(string[] args) 
        {
            string value;
            // Sample 1
            Console.WriteLine("Sample 1: Concurrent queue\r\n{0}", "".PadRight(26, '-'));
            
            ConcurrentQueueSample queue1 = new ConcurrentQueueSample();
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "1");
            queue1.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "2");
            queue1.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "3");
            queue1.Put(value);
            Thread.Sleep(2500);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "4");
            queue1.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "5");
            queue1.Put(value);
            queue1.Dispose();
            
            while (!queue1.IsCompleted)
            {
                Console.Write(".");
                Thread.Sleep(50);
            }
            Console.WriteLine("Press any key...");
            Console.ReadLine();
            
            // Sample 2
            Console.WriteLine("Sample 2: AutoResetEvent\r\n{0}", "".PadRight(26, '-'));
            
            AutoResetEventSample queue2 = new AutoResetEventSample();
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "1");
            queue2.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "2");
            queue2.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "3");
            queue2.Put(value);
            Thread.Sleep(5000);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "4");
            queue2.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "5");
            queue2.Put(value);
            queue2.Stop();
            Console.WriteLine("Press any key...");
            Console.ReadLine();
            
            // Sample 3
            Console.WriteLine("Sample 3: Wait and Pulse\r\n{0}", "".PadRight(26, '-'));
            
            WaitPulseSample queue3 = new WaitPulseSample();
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "1");
            queue3.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "2");
            queue3.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "3");
            queue3.Put(value);
            Thread.Sleep(2500);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "4");
            queue3.Put(value);
            Console.WriteLine("Current thread: {0}, put: {1}", Thread.CurrentThread.ManagedThreadId, value = "5");
            queue3.Put(value);
            queue3.Stop();
            Console.WriteLine("Press any key...");
            Console.ReadLine();
        }
        
    }
    
    public class ConcurrentQueueSample : IDisposable
    {
        // ConcurrentQueue by default
        private readonly BlockingCollection<string> _queue = new BlockingCollection<string>();
        private readonly Thread _worker;
        public bool IsCompleted { 
            get {
                return _queue.IsCompleted;
            }
        }
        public ConcurrentQueueSample ()
        {
            _worker = new Thread(Work);
            _worker.Start();
        }
        
        public void Dispose()
        {
            Console.WriteLine("Completing: {0:O}", DateTime.UtcNow);
            _queue.CompleteAdding();
            _worker.Join();
            Console.WriteLine("Complete: {0:O}", DateTime.UtcNow);
        }
        
        public void Put (string element)
        {
            _queue.Add(element);
        }
        
        private void Work()
        {
            // Последовательность, которую мы перебираем будет заблокирована,
            // когда не будет доступных элементов, и завершится после выззова.
            foreach (string value in _queue.GetConsumingEnumerable())
            {
                // Выполняем задачу.
                Console.WriteLine("Current thread: {0}, get: {1}, time: {2}", 
                    Thread.CurrentThread.ManagedThreadId, value, DateTime.UtcNow.Ticks);
                Thread.Sleep(1000);
            }
        }
    }
 
    public class AutoResetEventSample
    {
        private readonly EventWaitHandle _waitHandle = new AutoResetEvent(false);
        private readonly Queue<string> _queue = new Queue<string>();
        private object _locker = new object();
        private readonly Thread _worker;
 
        public AutoResetEventSample()
        {
            //Console.WriteLine(Thread.CurrentThread.Priority);
            _worker = new Thread(Work); // {Priority = ThreadPriority.BelowNormal};
            _worker.Start();
        }
 
        public void Put(string value)
        {
            lock (_locker)
            {
                _queue.Enqueue(value);
            }
            _waitHandle.Set();
        }
 
        public void Stop()
        {
            lock (_locker)
                _queue.Enqueue(null);
            _waitHandle.Set();
            _worker.Join();
        }
 
        private void Work()
        {
            int counter = 0;
            while (true)
            {
                string value = null;
                lock (_locker)
                {
                    if (_queue.Count > 0)
                    {
                        value = _queue.Dequeue();
                        if (value == null)
                        {
                            //Console.WriteLine(Thread.CurrentThread.Priority);
                            return;
                        }
                    }
                    else
                    {
                        Console.WriteLine("Current thread: {0}, get. Empty queue. Time: {0}, {1,2}", 
                            Thread.CurrentThread.ManagedThreadId, DateTime.UtcNow.Ticks, value == null);
                    }
                }
                if (value != null)
                {
                    Console.WriteLine("Current thread: {0}, get: {1}, time: {2}, counter: {3}", 
                        Thread.CurrentThread.ManagedThreadId, value, DateTime.UtcNow.Ticks, counter);
                    Thread.Sleep(1000);
                }
                else
                {
                    Console.WriteLine("WaitOne()");
                    _waitHandle.WaitOne();
                }
                counter++;
            }
        }
    }
    
    public class WaitPulseSample
    {
        private readonly Queue<string> _queue = new Queue<string>();
        private object _locker = new object();
        private readonly Thread _worker;
 
        public WaitPulseSample()
        {
            _worker = new Thread(Work);
            _worker.Start();
        }
 
        public void Put(string value)
        {
            lock (_locker)
            {
                _queue.Enqueue(value);           // We must pulse because we're
                Monitor.Pulse (_locker);         // changing a blocking condition.
            }
        }
 
        public void Stop()
        {
            Put(null);
            _worker.Join();
        }
 
        private void Work()
        {
            int counter = 0;
            while (true)                        // Keep consuming until
            {                                   // told otherwise.
                string value;
                lock (_locker)
                {
                    while (_queue.Count == 0) Monitor.Wait (_locker);
                    value = _queue.Dequeue();
                }
                if (value == null) return;         // This signals our exit.
                Console.WriteLine("Current thread: {0}, get: {1}, time: {2}, counter: {3}", 
                    Thread.CurrentThread.ManagedThreadId, value, DateTime.UtcNow.Ticks, counter);
                Thread.Sleep(1000);
                counter++;
            }
        }
    }
}