Multiple-writer thread-safe queue in C

I am working on a multi-threaded C application using pthreads. I have one thread which writes to a a database (the database library is only safe to be used in a single thread), and several threads which are gathering data, processing it, and then need to send the results to the database thread for storage. I've seen in mentioned that it is "possible" to make a multiple-writer safe queue in C, but every place I see this mentioned simply says that it's "too complicated for this example" and merely demonstrates a single-writer safe queue.

I need the following things:

EDIT: Reading threads should not spin on an empty queue, since there is likely to be minutes worth of time with no writes, with short bursts of large numbers of writes.


  • Sure, there are lockless queues. Based on what you've said in comments, though, performance here is not at all critical, since you're creating a thread per write anyway.

    So, this is a standard use case for a condition variable. Make yourself a struct containing a mutex, a condition variable, a linked list (or circular buffer if you like), and a cancel flag:

        lock the mutex
        (optionally - check the cancel flag to prevent leaks of stuff on the list)
        add the event to the list
        signal the condition variable
        unlock the mutex
       lock the mutex
       while (list is empty AND cancel is false):
           wait on the condition variable with the mutex
       if cancel is false:  // or "if list non-empty", depending on cancel semantics
           remove an event from the list
       unlock the mutex
       return event if we have one, else NULL meaning "cancelled"
       lock the mutex
       set the cancel flag
       (optionally - dispose of anything on the list, since the reader will quit)
       signal the condition variable
       unlock the mutex

    If you're using a list with external nodes, then you might want to allocate the memory outside the mutex lock, just to reduce the time its held for. But if you design the events with an intrusive list node that's probably easiest.

    Edit: you can also support multiple readers (with no portable guarantees for which one gets a given event) if in cancel you change the "signal" to "broadcast". Although you don't need it, it doesn't really cost anything either.