Thread with an ArrayList in c#

You can use the Monitor class to synchronize your threads. Here is an example using five different locks and queues, one for each thread, based on your comments.

It's important to protect with a lock any data shared between two different threads. Only the thread holding the lock should access the data.

The worker thread locks on its own personal object (in the syncs array), and, having the lock, then calls Monitor.Wait, which will release the lock.

The main thread may have already tried to lock that thread's sync object, or soon will, it doesn't matter because it won't have access to that thread's queue until it does have the lock. Then it is safe to queue up a message. The Monitor.Pulse call wakes up the waiting worker thread, but the worker stays stuck in its Monitor.Wait call until the main thread releases the lock (by falling out of the lock() { } code block.)

When Monitor.Wait returns to the worker, the lock will have been re-acquired.

You can't always assume that the threads will pulse and wake at the same rate, which is why I have the extra while loop in the worker thread, to handle the case where the main thread has signaled a few times with several messages before the worker actually woke up to process them.

This example is much simplified -- it doesn't cover shutting the workers down, for example, but it should give you some ideas get started.

namespace ConsoleApplication1
{
    using System;
    using System.Collections.Generic;
    using System.Threading;

    internal class Program
    {
        private static readonly Queue<int>[] queues = new Queue<int>[5];

        private static readonly object[] syncs = new object[5];

        public static void Main(string[] args)
        {
            for (int i = 0; i < 5; i++)
            {
                queues[i] = new Queue<int>();
                syncs[i] = new object();
                var thread = new Thread(ThreadProc);
                thread.Start(i);
            }

            var random = new Random();
            while (true)
            {
                Thread.Sleep(1000);
                int index = random.Next(queues.Length);
                lock (syncs[index])
                {
                    int message = random.Next(100);
                    queues[index].Enqueue(message);
                    Console.WriteLine("Sending message " + message + " to thread at " + index);
                    Monitor.Pulse(syncs[index]);
                }
            }
        }

        private static void ThreadProc(object data)
        {
            var index = (int)data;
            lock (syncs[index])
            {
                while (true)
                {
                    while (queues[index].Count == 0)
                    {
                        Monitor.Wait(syncs[index]);
                    }

                    int message = queues[index].Dequeue();
                    Console.WriteLine("Thread at " + index + " received message " + message);
                }
            }
        }
    }
}