Событие добавления нового члена в коллекцию FIFO

//очередь новых сообщений
static Queue<object> qe = new Queue<object>();
 
//оповещение  о новом сообщение
public delegate void StatisticMessage();
public static event StatisticMessage newMessage;
 
private static Thread thread1;
private static Thread thread2;
 
static void Main(string[] args)
{
     newMessage +=messageProcessor;
     Thread thread1 = new Thread(AddToFIFO);
     thread1.Start();
     Console.ReadKey();
}
 
//добавляю в очередь 10 сообщений
public static void AddToFIFO()
{
     for (var i = 10; i > 0; i--)
     {
          string message = i.ToString();;
 
          //"в очередь, сукины дети, в очередь"
          EnqueueQueueMessage(message);
     }
}
 
//функция добавления + оповещение о добавлении
public static void EnqueueQueueMessage(object message)
{
     qe.Enqueue(message); 
 
     try
     {
          newMessage();
     }
     catch (Exception e)
     {
          Console.WriteLine(e.Message + " " + e.TargetSite + " " + e.StackTrace + "\n");
     }
}
 
//подписчик оповещения о добавлении
public static void messageProcessor()
{
     processing(qe.Dequeue); // в таком виде обрабатывается по порядку, но пока 
//обработчик  3 секунды не поспит, новое сообщение не принимается
 
     /*
     если сделать тут поток, то вроде всё ок, но последовательность обработки сообщений сбивается.
 
     thread2=new Thread(Processing);
     thread2.Start(qe.Dequeue)
 
     предполагаю что нужно делать какую-то блокировку потоков, чтобы они обрабатывали 
     сообщения в том порядке в каком поток вызывается, а не как им вздумается.
     */
}
 
//обработка сообщения
public static void Processing(object message)
{
     Thread.Sleep(3000);
     Console.WriteLine((string)message);
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace Producer_Consumer {
    public class ProducerConsumerQueue: IDisposable {
        EventWaitHandle wh = new AutoResetEvent(false);
        Thread worker;
        object locker = new object();
        Queue<string> tasks = new Queue<string>();
 
        public ProducerConsumerQueue() {
            worker = new Thread(Work);
            worker.Start();
        }
        public void EnqueueTask(string task) {
            lock (locker) {
                tasks.Enqueue(task);
                wh.Set();
            }
        }
        public void Dispose() {
            EnqueueTask(null);
            worker.Join();
            wh.Close();
        }
        void Work() {
            while (true) {
                string task = null;
                lock (locker) {
                    if (tasks.Count > 0) {
                        task = tasks.Dequeue();
                        if (task == null)
                            return;
                    }
                }
                if (task != null) {
                    Console.WriteLine("Produce task: {0}", task.ToString());
                    Thread.Sleep(2000);
                }
                else
                    wh.WaitOne();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Producer_Consumer {
    class Program {
        static void Main(string[] args) {
            using (ProducerConsumerQueue q=new ProducerConsumerQueue()){
                for (int i = 0; i < 10; i++) {
                    q.EnqueueTask(i.ToString());
                }
            }
            Console.ReadLine();
        }
    }
}

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
class Program
{
    static Random random = new Random();
    static void Main()
    {
        var proc = new MyProcessor();
        proc.NewMessage += (sender, args) =>
        {
            Thread.Sleep(random.Next(500, 4000)); // симулируем задержку
            Console.WriteLine("Object {0} sended message {1}", sender, args.Data);
        };
        proc.Start();
        Thread.Sleep(TimeSpan.FromSeconds(10));
        proc.Stop();
    }
}
 
 
 
class MyProcessor
{
    public class MessageEventArgs : EventArgs
    {
        public string Data { get; set; }
 
        public MessageEventArgs(string data)
        {
            Data = data;
        }
    }
 
    public EventHandler<MessageEventArgs> NewMessage = delegate { };
    public bool IsWorking { get; set; }
 
    private int maxmessages = 10; //для тестовых целей
 
    public void Start()
    {
        IsWorking = true;
        Task.Factory.StartNew(Work);
    }
 
    public void Stop()
    {
        IsWorking = false;
    }
 
    private void Work()
    {
        while (IsWorking && maxmessages-->0)
        {
            var msg = ReadMessage();
            Task.Factory.StartNew(() => NewMessage(this, new MessageEventArgs(msg)));
            Console.WriteLine("Message proceeded");
        }
    }
 
    private string ReadMessage()
    {
        var count = Environment.TickCount;
        return count%2 == 0 ? "tick" : "tack";
    }
}

public event EventHandler<MessageEventArgs> NewMessage = delegate { };