Question

I have a class which reads from a message queue. Now this class has also got a thread inside it. Depending on the type of the msg in msg q, it needs to execute different functions inside that thread as the main thread in class always keeps on waiting on msg q. As soon as it reads a message from queue, it checks its type and calls appropriate method to be executed in thread and then it goes back to reading again(reading in while loop).

I am using boost message q and boost threads
How can I do this.
Its something like this:

while(!quit) {        
    try
    {                        
        ptime now(boost::posix_time::microsec_clock::universal_time());
        ptime timeout = now + milliseconds(100);

        if (mq.timed_receive(&msg, sizeof(msg), recvd_size, priority, timeout))
        {                
            switch(msg.type)
            {
             case collect:
                {
                    // need to call collect method  in thread
                }
                break;                
            case query:
                {
                    // need to call query method  in thread
                }
                break;

and so on.
Can it be done?

If it can be done, then what happens in the case when thread is say executing collect method and main thread gets a query message and wants to call it.
Thanks in advance.

Answer 1

Messages arriving while the receiving thread is executing long operations will be stored for later (in the queue, waiting to be processed).

If the thread is done with its operation, it will come back and call the receive function again, and immediately get the first of the messages that arrived while it was not looking and can process it.

If the main thread needs the result of the message processing operation, it will block until the worker thread is done and delivers the result.

Make sure you do not do anything inside the worker thread that in turn waits on the main thread’s actions, otherwise there is the risk of a deadlock.