Message passing between threads in C

Question

I am trying to get Thread A to communicate with Thread B. I should be using message passing between threads to do this but I am trying to find some sample source code which explains message passing.

Does anyone have any good link to some sample source code (in C) which explains message passing ?

Use some common data structure, protected by some kind of lock. — Basile Starynkevitch, Nov 24 '11 at 07:06
Message passing could mean semaphores or condvars, did your tutor give you any hints about it? — IanNorton, Nov 24 '11 at 07:06
1. I need to learn message passing first, so don't have any source code. 2. I'm pretty sure its message passing and i'm not entirely sure how it works 3. I'm thinking its a part of inter process communication, but there are no hints — Ashish Agarwal, Nov 24 '11 at 07:09
Some examples with POSIX and SysV message queue here http://menehune.opt.wfu.edu/Kokua/More_SGI/007-2478-008/sgi_html/ch06.html — chill, Nov 24 '11 at 08:34

score 13 · Accepted Answer · answered Nov 24 '11 at 07:14

While not having a link, there are many ways to implement this.

First is to use sockets. This is not actually a method I would recommend, as it can be quite a lot of work to get it to work right.
The second is related to the first method, and is to use something called anonymous pipes.
A third way, and the one I usually use, is "inspired" by how message passing worked on the old Amiga operating system: Simply use a queue. Since memory is shared between threads it's easy to just pass pointers around. Use one queue per thread. Just remember to protect the queues, with something like a mutex.
The platform you are using will probably have other ways of communication. Do a Google search for (for example) linux ipc.

@AshishAgarwal Ok, then search for _linux ipc_ :) – Some programmer dude Nov 24 '11 at 07:17 — Some programmer dude, Nov 24 '11 at 07:17
It's SysV IPC and Unix pipes/sockets. – Kenneth Nov 24 '11 at 08:53 — Kenneth, Nov 24 '11 at 08:53

score 3 · Answer 2 · answered Nov 24 '11 at 07:07

ONe very easy way that's fairly fast on Linux at least is to use either TCP or UDP sockets for message passing between threads. The Linux kernel is pretty smart and if I remember correctly it will bypass the network stack which makes it pretty fast. Then you don't have to worry about locking and various other issues which are basically handled by the kernel. Should be good enough for a homework assignment.

Uri's TCP/IP Resources List FAQs, tutorials, guides, web pages & sites, and books about TCP/IP

Why the downvote? Especially since the accepted answer mentions sockets as one possible solution. — Robert S. Barnes, Nov 25 '13 at 19:32

score 1 · Answer 3 · answered Nov 24 '11 at 07:10

Each thread in a process can see all of the memory of other threads. If two threads hold a pointer to the same location in memory, then they can both access it.

Following is the code but not tested.

struct MessageQueue
{
    std::queue<std::string> msg_queue;
    pthread_mutex_t mu_queue;
    pthread_cond_t cond;
};

{
    // In a reader thread, far, far away...
    MessageQueue *mq = <a pointer to the same instance that the main thread has>;
    std::string msg = read_a_line_from_irc_or_whatever();
    pthread_mutex_lock(&mq->mu_queue);
    mq->msg_queue.push(msg);
    pthread_mutex_unlock(&mq->mu_queue);
    pthread_cond_signal(&mq->cond);
}

{
    // Main thread
    MessageQueue *mq = <a pointer to the same instance that the main thread has>;

    while(1)
    {
        pthread_mutex_lock(&mq->mu_queue);
        if(!mq->msg_queue.empty())
        {
            std::string s = mq->msg_queue.top();
            mq->msg_queue.pop();
            pthread_mutex_unlock(&mq->mu_queue);
            handle_that_string(s);
        }
        else
        {
            pthread_cond_wait(&mq->cond, &mq->mu_queue)
        }
    }

While message queues are nice, the OP tagged the question with "c" so can't use `std::queue`. — Some programmer dude, Nov 24 '11 at 07:15
WARNING: This is a code sketch. It does not come close to compiling. Some assembly required. — Jonathan Ben-Avraham, Feb 05 '23 at 13:04

Message passing between threads in C

3 Answers3

Linked