Start threads at the order that they were started, only when previous thread was finished

Question

Sorry for the confusing title, but that's basically what i need, i could do something with global variables but that would only be viable for 2 threads that are requested one after the other.

here is a pseudo code that might explain it better.

 /*Async function that gets requests from a server*/
        if ()//recieved request from server
        {
            new Thread(() =>
            {
                //do stuff
                //in the meantime a new thread has been requested from server
                //and another one 10 seconds later.. etc.

                //wait for this current thread to finish
                //fire up the first thread that was requested while this ongoing thread
                //after the second thread is finished fire up the third thread that was requested 10 seconds after this thread
                //etc...
            }).Start();
        }

I don't know when each thread will be requested, as it is based on the server sending info to client, so i cant do Task.ContiuneWith as it's dynamic.

So Michael suggested me to look into Queues, and i came up with it

    static Queue<Action> myQ = new Queue<Action>();
    static void Main(string[] args)
    {
        new Thread(() =>
       {
           while (1 == 1)
           {
               if (myQ.FirstOrDefault() == null)
                   break;
               myQ.FirstOrDefault().Invoke();
           }
       }).Start();

        myQ.Enqueue(() =>
        {
            TestQ("First");
        });
        myQ.Enqueue(() =>
        {
            TestQ("Second");
        });
        Console.ReadLine();
    }
    private static void TestQ(string s)
    {
        Console.WriteLine(s);  
        Thread.Sleep(5000);
        myQ.Dequeue();
    }

I commented the code, i basically need to check if the act is first in queue or not.

EDIT: So i re-made it, and now it works, surely there is a better way to do this ? because i cant afford to use an infinite while loop.

Answer 1

You will have to use a global container for the threads. Maybe check Queues.

This class implements a queue as a circular array. Objects stored in a Queue are inserted at one end and removed from the other.

Queues and stacks are useful when you need temporary storage for information; that is, when you might want to discard an element after retrieving its value. Use Queue if you need to access the information in the same order that it is stored in the collection. Use Stack if you need to access the information in reverse order. Use ConcurrentQueue(Of T) or ConcurrentStack(Of T) if you need to access the collection from multiple threads concurrently.

Three main operations can be performed on a Queue and its elements:

• Enqueue adds an element to the end of the Queue.
• Dequeue removes the oldest element from the start of the Queue.
• Peek returns the oldest element that is at the start of the Queue but does not remove it from the Queue.

EDIT (From what you added) Here is how I would change your example code to implement the infinite loop and keep it under your control.

static Queue<Action> myQ = new Queue<Action>();
static void Main(string[] args)
{ 
    myQ.Enqueue(() =>
    {
        TestQ("First");
    });
    myQ.Enqueue(() =>
    {
        TestQ("Second");
    });
    Thread thread = new Thread(() =>
    {                             
        while(true) {
            Thread.Sleep(5000)
            if (myQ.Count > 0) {
                myQ.Dequeue().Invoke()
            }
        }
    }).Start();
    // Do other stuff, eventually calling "thread.Stop()" the stop the infinite loop.
    Console.ReadLine();
}
private static void TestQ(string s)
{
    Console.WriteLine(s);
}

Answer 2

You could put the requests that you receive into a queue if there is a thread currently running. Then, to find out when threads return, they could fire an event. When this event fires, if there is something in the queue, start a new thread to process this new request.

The only thing with this is you have to be careful about race conditions, since you are communicating essentially between multiple threads.